better-supabase 0.12.0 → 0.14.0

package/dist/recordings-DgDu7AOt.d.ts

@@ -0,0 +1,119 @@
+/// <reference lib="esnext.temporal" />
+import { o as AiFile } from "./types-BEDfwXL4.js";
+//#region src/blocks/engagements/recordings.d.ts
+/** The queue a recording's transcription job goes on, with the jobs block. */
+declare const ENGAGEMENT_TRANSCRIBE_QUEUE = "engagements.transcribe";
+/** `pending` until a transcript is saved; `failed` when the transcriber gave up. */
+type EngagementRecordingStatus = "pending" | "transcribed" | "failed";
+/** A call or meeting recording: an ai-files file on an engagement. */
+interface EngagementRecording {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly engagementId: string;
+  readonly fileId: string;
+  readonly filename: string;
+  readonly mediaType: string;
+  readonly status: EngagementRecordingStatus;
+  /** A BCP 47 tag such as `en` or `nl-NL`, given or detected. */
+  readonly language?: string;
+  readonly durationSeconds?: number;
+  /** Why the transcriber failed. */
+  readonly error?: string;
+  /** The transcriber's model. */
+  readonly model?: string;
+  readonly segmentCount: number;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly transcribedAt?: Temporal.Instant;
+}
+/** One speaker turn of a transcript. */
+interface TranscriptSegment {
+  /** 1 for the first turn. */
+  readonly position: number;
+  /** The speaker's label, such as `Speaker 1` or a name. */
+  readonly speaker?: string;
+  /** The member who spoke, when known. */
+  readonly speakerUserId?: string;
+  /** Milliseconds from the start of the recording. */
+  readonly startMs: number;
+  readonly endMs: number;
+  readonly text: string;
+  /** Between 0 and 1. */
+  readonly confidence?: number;
+}
+type TranscriptSegmentInput = Omit<TranscriptSegment, "position">;
+/** What a transcriber returns and `saveTranscript` stores. */
+interface Transcript {
+  /** In order; `startMs` at most `endMs`. */
+  readonly segments: readonly TranscriptSegmentInput[];
+  readonly language?: string;
+  readonly durationSeconds?: number;
+}
+/** What `Transcriber.transcribe` gets for one recording. */
+interface TranscriberInput {
+  readonly file: Pick<AiFile, "id" | "filename" | "mediaType">;
+  /** A signed URL to the audio or video, for providers that fetch it. */
+  readonly url: string;
+  /** The bytes, for providers that take an upload. */
+  read(): Promise<Uint8Array>;
+  /** The language given when the recording was attached. */
+  readonly language?: string;
+}
+/**
+ * Turns a recording into speaker turns. Wrap any speech-to-text API or SDK in
+ * the app; the block imports none.
+ */
+interface Transcriber {
+  /** The transcriber contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  readonly model: string;
+  transcribe(input: TranscriberInput, options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<Transcript>;
+}
+/** A follow-up a note names. */
+interface EngagementActionItem {
+  readonly text: string;
+  readonly ownerId?: string;
+  readonly dueAt?: Temporal.Instant;
+}
+/** What `saveNotes` stores and a note taker returns. */
+interface EngagementNotesInput {
+  readonly summary: string;
+  readonly actionItems?: readonly EngagementActionItem[];
+}
+/** The notes on an engagement: a summary and its action items. */
+interface EngagementNotes {
+  readonly engagementId: string;
+  readonly organizationId: string;
+  readonly summary: string;
+  readonly actionItems: readonly EngagementActionItem[];
+  /** The note taker's model, for notes an AI wrote. */
+  readonly model?: string;
+  /** `ai` from `summarize`, `member` when a member wrote them. */
+  readonly source: "ai" | "member";
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** What `NoteTaker.summarize` gets: the engagement and its transcripts. */
+interface NoteTakerInput<E> {
+  readonly engagement: E;
+  readonly transcript: readonly (TranscriptSegment & {
+    readonly recordingId: string;
+  })[];
+}
+/**
+ * Writes a summary and action items for an engagement from its transcripts.
+ * Wrap any model in the app; the block imports no AI SDK (ADR 0010).
+ */
+interface NoteTaker {
+  /** The note taker contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+  readonly model: string;
+  summarize<E>(input: NoteTakerInput<E>, options?: {
+    readonly signal?: AbortSignal;
+  }): Promise<EngagementNotesInput>;
+}
+//#endregion
+export { EngagementRecording as a, NoteTakerInput as c, Transcript as d, TranscriptSegment as f, EngagementNotesInput as i, Transcriber as l, EngagementActionItem as n, EngagementRecordingStatus as o, TranscriptSegmentInput as p, EngagementNotes as r, NoteTaker as s, ENGAGEMENT_TRANSCRIBE_QUEUE as t, TranscriberInput as u };

package/dist/records/index.d.ts

@@ -0,0 +1,83 @@
+import { b as DbError, t as AsyncResult } from "../result-C6jDfedy.js";
+import { dt as SubjectRef } from "../executor-CPyrQdjh.js";
+import { $t as sectionRowInput, Bt as SectionMap, Ft as AnySection, Gt as SectionWrite, Ht as SectionPermissions, It as AnySectionWrite, Jt as SectionWriteOutput, Kt as SectionWriteInput, Lt as Section, Qt as sectionEventMatches, Rt as SectionData, Ut as SectionResult, Vt as SectionOptions, Wt as SectionRowInput, Xt as TimelineItem, Yt as SectionWrites, Zt as defineSection, en as sectionWrite, qt as SectionWriteName, zt as SectionDefinition } from "../define-block-COpcS6aT.js";
+import { A as LoadSectionsOptions, B as PermissionFlags, C as defineRecordFeature, D as recordPermissionKeys, E as recordCan, F as SectionNamed, H as can, I as SectionSource, L as countSection, M as SectionBlocks, N as SectionCheck, O as recordSubject, P as SectionName, R as loadSections, S as SectionWritesOf, T as plainData, U as permissionFlags, V as PermissionSet, _ as PlainSections, b as RecordFeatureSpec, d as FeatureBlocks, f as FeaturePermissions, g as PlainSection, h as Plain, j as LoadedSections, k as recordWriteInput, m as FeatureWriteOutput, p as FeatureWriteInput, v as RecordCan, w as findSectionWrite, x as RecordWriteInput, y as RecordFeature, z as sectionCan } from "../index-DbXWcrOI.js";
+import { p as SubscriptionStatus } from "../topic-D9j8G2dw.js";
+import { n as TopicPort } from "../watch-topic-CIT3UlAh.js";
+import { n as Controller, t as AuthPort } from "../controller-DAD4hbl4.js";
+import { a as RecordSummaryOptions, c as Subjects, f as MyWorkKind, i as RecordSummary, n as MyWorkItem, r as MyWorkOptions } from "../subjects-DXFmanh5.js";
+import { a as timelineSections, c as RecordListCells, d as RecordListQuery, f as RecordListRow, h as defineRecordList, i as loadTimeline, l as RecordListColumn, m as RecordListSpec, n as Timeline, o as RecordList, p as RecordListSource, r as TimelineEntry, s as RecordListCell, t as LoadTimelineOptions, u as RecordListPage } from "../timeline-DUUsPLv5.js";
+import { a as EntityFormOptions, c as entityForm, i as EntityFormInput, n as EntityFormCustomField, o as EntityFormResult, r as EntityFormField, s as EntityFormValues, t as EntityForm } from "../entity-form-B67vq97h.js";
+//#region src/records/controller.d.ts
+interface RecordControllerOptions<B extends SectionBlocks, N extends SectionName<B>> extends LoadSectionsOptions<B, N> {
+  readonly source: SectionSource<B>;
+  readonly auth: AuthPort;
+  readonly ports: {
+    readonly topic: TopicPort;
+  };
+  /** The record to follow; nothing loads without one. */
+  readonly subject: SubjectRef | null;
+  readonly sections: readonly N[];
+  /**
+   * The one private topic that hears of changes to the record, such as a
+   * broadcast of its block events. A message whose event a section lists in
+   * `events` loads that section again; any other message loads every section.
+   * Default `null`: sections load again on `refresh` only.
+   */
+  readonly topic?: string | null;
+  /**
+   * The subjects client, to load `record_summary` (title, counts, unread) next
+   * to the sections.
+   */
+  readonly summary?: Pick<Subjects, "summary">;
+  readonly summaryOptions?: RecordSummaryOptions;
+}
+interface RecordSnapshot<B extends SectionBlocks, N extends string> {
+  /** Each section settled; `undefined` until the first load. */
+  readonly sections: Partial<LoadedSections<B, N>> | undefined;
+  /** The record's title, counts and unread state, with `summary`. */
+  readonly summary: RecordSummary | undefined;
+  readonly status: SubscriptionStatus;
+  /** The error of the last summary load. */
+  readonly error: DbError | undefined;
+}
+interface RecordActions<N extends string> {
+  /** Loads the named sections again, or every section and the summary. */
+  readonly refresh: (names?: readonly N[]) => Promise<void>;
+}
+type RecordController<B extends SectionBlocks, N extends string> = Controller<RecordSnapshot<B, N>, RecordActions<N>>;
+/**
+ * One record page's sections for the signed-in user over one realtime
+ * subscription (ADR 0030): it loads them with `loadSections`, and loads a
+ * section again when `topic` carries one of its events.
+ */
+export declare function createRecordController<B extends SectionBlocks, const N extends SectionName<B>>(options: RecordControllerOptions<B, N>): RecordController<B, N>;
+//#endregion
+//#region src/records/my-work.d.ts
+/** What `loadMyWork` returns: the items, grouped by kind, and their counts. */
+interface MyWork {
+  /** Every item, newest first. */
+  readonly items: readonly MyWorkItem[];
+  /** The items of each kind, newest first; an empty list for a kind with none. */
+  readonly groups: Readonly<Record<MyWorkKind, readonly MyWorkItem[]>>;
+  /** How many items of each kind the page holds, for tab badges. */
+  readonly counts: Readonly<Record<MyWorkKind, number>>;
+}
+interface LoadMyWorkOptions extends MyWorkOptions {
+  /** Only these kinds, such as `["assigned", "approval"]`. Default: all. */
+  readonly kinds?: readonly MyWorkKind[];
+}
+/**
+ * The caller's "My work" page: `my_work` across the installed blocks, grouped
+ * by kind with a count each, in one round trip.
+ *
+ * ```ts
+ * const work = await loadMyWork(blocks.subjects, {
+ *   pageSize: 100,
+ * }).orThrow();
+ * work.groups.approval; // approvals the caller can decide
+ * ```
+ */
+export declare function loadMyWork(subjects: Pick<Subjects, "myWork">, options?: LoadMyWorkOptions): AsyncResult<MyWork>;
+//#endregion
+export { type AnySection, type AnySectionWrite, type EntityForm, type EntityFormCustomField, type EntityFormField, type EntityFormInput, type EntityFormOptions, type EntityFormResult, type EntityFormValues, type FeatureBlocks, type FeaturePermissions, type FeatureWriteInput, type FeatureWriteOutput, type LoadMyWorkOptions, type LoadSectionsOptions, type LoadTimelineOptions, type LoadedSections, type MyWork, type MyWorkItem, type MyWorkKind, type MyWorkOptions, type PermissionFlags, type PermissionSet, type Plain, type PlainSection, type PlainSections, type RecordActions, type RecordCan, type RecordController, type RecordControllerOptions, type RecordFeature, type RecordFeatureSpec, type RecordList, type RecordListCell, type RecordListCells, type RecordListColumn, type RecordListPage, type RecordListQuery, type RecordListRow, type RecordListSource, type RecordListSpec, type RecordSnapshot, type RecordSummary, type RecordSummaryOptions, type RecordWriteInput, type Section, type SectionBlocks, type SectionCheck, type SectionData, type SectionDefinition, type SectionMap, type SectionName, type SectionNamed, type SectionOptions, type SectionPermissions, type SectionResult, type SectionRowInput, type SectionSource, type SectionWrite, type SectionWriteInput, type SectionWriteName, type SectionWriteOutput, type SectionWrites, type SectionWritesOf, type Timeline, type TimelineEntry, type TimelineItem, can, countSection, defineRecordFeature, defineRecordList, defineSection, entityForm, findSectionWrite, loadSections, loadTimeline, permissionFlags, plainData, recordCan, recordPermissionKeys, recordSubject, recordWriteInput, sectionCan, sectionEventMatches, sectionRowInput, sectionWrite, timelineSections };

package/dist/records/index.js

@@ -0,0 +1,315 @@
+import { n as dbError } from "../errors-03ysrOt4.js";
+import { c as optionalTemporal } from "../temporal-DLZlWbOi.js";
+import { a as ok, t as AsyncResult } from "../result-B3m7xtRY.js";
+import { t as CUSTOM_FIELD_FORM_TYPES } from "../field-formats-C6QKA3UR.js";
+import { i as sectionWrite, n as sectionEventMatches, r as sectionRowInput, t as defineSection } from "../sections-DjxYmpu-.js";
+import { n as permissionFlags, t as can } from "../permissions-BetA_Fo_.js";
+import { a as recordCan, c as recordWriteInput, d as findSection, f as loadSections, i as plainData, o as recordPermissionKeys, p as sectionCan, r as findSectionWrite, s as recordSubject, t as defineRecordFeature, u as countSection } from "../feature-BBLdbGu7.js";
+import { t as createRecordController } from "../controller-CSsC9s3s.js";
+import { n as timelineSections, t as loadTimeline } from "../timeline-0_hTBH0-.js";
+import { t as MY_WORK_KINDS } from "../my-work-kinds-BU3SlA-6.js";
+//#region src/records/list.ts
+/**
+* `subjectKey` from `core/block-subjects.ts`, the key `countSection` and
+* `column` results use. Inlined so the records entry doesn't load the block
+* helpers.
+*/
+function subjectKey(subject) {
+	return `${subject.type}:${subject.id}`;
+}
+function rowId(row) {
+	const id = typeof row === "object" && row !== null && "id" in row ? row.id : void 0;
+	return typeof id === "string" || typeof id === "number" ? String(id) : "";
+}
+function loadEach(load, client, subjects) {
+	return AsyncResult.from(async () => {
+		const results = await Promise.all(subjects.map(async (subject) => [subjectKey(subject), await load(client, subject, void 0)]));
+		const values = {};
+		for (const [key, result] of results) {
+			if (!result.ok) return result;
+			values[key] = result.data;
+		}
+		return ok(values);
+	});
+}
+function columnOf(blocks, clients, name, mode, subjects) {
+	const found = findSection(blocks, name);
+	const client = clients[found?.key ?? ""];
+	if (found === void 0 || client === void 0) return AsyncResult.err(dbError("invalid_request", `Section "${name}" has no block client`));
+	const count = found.section.count;
+	const column = found.section.column;
+	const load = found.section.load;
+	if (mode === "count") return count === void 0 ? AsyncResult.err(dbError("unsupported", `Section "${name}" can't count rows`)) : count(client, subjects);
+	return column === void 0 ? loadEach(load, client, subjects) : column(client, subjects);
+}
+/**
+* A subject's list page over the sections of its record feature: `load` parses
+* the URL state, runs the list query, and fills each section column for the
+* whole page (a comment count, the tags) in one wave, with the caller's `can`
+* flags.
+*
+* ```ts
+* export const customerRecordList = defineRecordList(
+*   customerFeature,
+*   customerList,
+*   { columns: { comments: "count", tags: "data" } },
+* );
+* ```
+*/
+function defineRecordList(feature, list, spec = {}) {
+	const columns = spec.columns ?? {};
+	const idOf = spec.id ?? rowId;
+	const entries = Object.entries(columns).filter((entry) => entry[1] !== void 0);
+	return {
+		feature,
+		list,
+		columns,
+		load(source, input, options) {
+			const parsed = list.parse(input, options);
+			if (!parsed.ok) return AsyncResult.err(dbError("validation", "Invalid list state", { issues: parsed.issues }));
+			const can = recordCan(feature, source.permissions);
+			const flags = can;
+			return list.run(source.db, parsed.value).andThen(async (page) => {
+				const { items, ...rest } = page;
+				const listed = items.map((row) => ({
+					row,
+					subject: recordSubject(feature, idOf(row))
+				}));
+				const subjects = listed.map((each) => each.subject);
+				const cells = await Promise.all(entries.map(async ([name, mode]) => {
+					if (flags[name]?.read === false) return [
+						name,
+						mode,
+						{ kind: "hidden" }
+					];
+					const result = await columnOf(feature.blocks, source.clients, name, mode, subjects);
+					return [
+						name,
+						mode,
+						result.ok ? {
+							kind: "ok",
+							data: result.data
+						} : {
+							kind: "error",
+							error: result.error
+						}
+					];
+				}));
+				return AsyncResult.ok({
+					query: parsed.value,
+					page: rest,
+					rows: listed.map(({ row, subject }) => {
+						const key = subjectKey(subject);
+						return {
+							subject,
+							row,
+							cells: Object.fromEntries(cells.map(([name, mode, result]) => [name, result.kind === "ok" ? {
+								kind: "ok",
+								data: result.data[key] ?? (mode === "count" ? 0 : void 0)
+							} : result]))
+						};
+					}),
+					filterFields: list.filterFields(),
+					can
+				});
+			});
+		}
+	};
+}
+//#endregion
+//#region src/records/my-work.ts
+/**
+* The caller's "My work" page: `my_work` across the installed blocks, grouped
+* by kind with a count each, in one round trip.
+*
+* ```ts
+* const work = await loadMyWork(blocks.subjects, {
+*   pageSize: 100,
+* }).orThrow();
+* work.groups.approval; // approvals the caller can decide
+* ```
+*/
+function loadMyWork(subjects, options = {}) {
+	const { kinds, ...rest } = options;
+	const wanted = new Set(kinds ?? MY_WORK_KINDS);
+	return subjects.myWork(rest).map((all) => {
+		const items = all.filter((item) => wanted.has(item.kind));
+		const of = (kind) => items.filter((item) => item.kind === kind);
+		const groups = {
+			assigned: of("assigned"),
+			approval: of("approval"),
+			reminder: of("reminder"),
+			mention: of("mention"),
+			sla: of("sla")
+		};
+		return {
+			items,
+			groups,
+			counts: {
+				assigned: groups.assigned.length,
+				approval: groups.approval.length,
+				reminder: groups.reminder.length,
+				mention: groups.mention.length,
+				sla: groups.sla.length
+			}
+		};
+	});
+}
+//#endregion
+//#region src/records/entity-form.ts
+const INTEGER_TEXT = /^-?\d+$/;
+const OFFSET = /(?:Z|[+-]\d{2}:\d{2})$/i;
+const BOOLEAN_TEXT = {
+	true: true,
+	on: true,
+	false: false
+};
+function parsed(read, raw) {
+	try {
+		return read();
+	} catch {
+		return raw;
+	}
+}
+/**
+* The value an input's text stands for, by the field's kind; text that doesn't
+* parse stays text, so the schema reports it.
+*/
+function coerce(spec, value, timeZone) {
+	const temporal = optionalTemporal();
+	switch (spec.kind) {
+		case "integer":
+		case "number": {
+			const number = Number(value);
+			return Number.isNaN(number) ? value : number;
+		}
+		case "bigint": return INTEGER_TEXT.test(value) ? BigInt(value) : value;
+		case "boolean": return BOOLEAN_TEXT[value] ?? value;
+		case "instant": return temporal === void 0 ? value : parsed(() => OFFSET.test(value) ? temporal.Instant.from(value) : temporal.PlainDateTime.from(value).toZonedDateTime(timeZone).toInstant(), value);
+		case "plainDate": return temporal === void 0 ? value : parsed(() => temporal.PlainDate.from(value), value);
+		case "plainDateTime": return temporal === void 0 ? value : parsed(() => temporal.PlainDateTime.from(value), value);
+		case "json": return parsed(() => JSON.parse(value), value);
+		case "uuid":
+		case "string":
+		case "datetime":
+		case "date":
+		case "enum":
+		case "custom":
+		case "unknown": return value;
+		default: return spec;
+	}
+}
+/** `dueAt` and `due_at` are `Due at`. */
+function labelOf(key) {
+	const words = key.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll("_", " ").toLowerCase().trim();
+	return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function inputOf(spec) {
+	switch (spec.kind) {
+		case "uuid":
+		case "string": return "text";
+		case "integer":
+		case "bigint": return "integer";
+		case "number": return "number";
+		case "boolean": return "bool";
+		case "date":
+		case "plainDate": return "date";
+		case "datetime":
+		case "instant":
+		case "plainDateTime": return "datetime";
+		case "enum": return spec.array === true ? "multi" : "option";
+		case "json":
+		case "custom":
+		case "unknown": return "json";
+		default: return spec;
+	}
+}
+function entityField(key, spec, label) {
+	return {
+		key,
+		label,
+		input: inputOf(spec),
+		required: spec.optional !== true && spec.nullable !== true,
+		source: "entity",
+		...spec.description === void 0 ? {} : { description: spec.description },
+		...spec.kind === "enum" ? { options: spec.values } : {},
+		...spec.minimum === void 0 ? {} : { minimum: spec.minimum },
+		...spec.maximum === void 0 ? {} : { maximum: spec.maximum },
+		...spec.minLength === void 0 ? {} : { minLength: spec.minLength },
+		...spec.maxLength === void 0 ? {} : { maxLength: spec.maxLength }
+	};
+}
+function isCustomFieldType(type) {
+	return Object.hasOwn(CUSTOM_FIELD_FORM_TYPES, type);
+}
+function customField(definition, label) {
+	return {
+		key: definition.key,
+		label: label ?? definition.label,
+		input: isCustomFieldType(definition.type) ? CUSTOM_FIELD_FORM_TYPES[definition.type] : "text",
+		required: definition.required,
+		source: "custom",
+		...definition.sensitive === true ? { sensitive: true } : {}
+	};
+}
+function isBlank(value) {
+	return value === void 0 || value === null || typeof value === "string" && value.trim() === "" || Array.isArray(value) && value.length === 0;
+}
+/**
+* The fields of a form for one of a block's entities, from its input schema
+* (`block.schemas.<entity>.input`) and the tenant's custom fields. `validate`
+* runs the schema, so the form accepts what the block's `create` accepts.
+*
+* ```ts
+* const form = entityForm(workItemsBlock.schemas.work_item.input, {
+*   fields: ["title", "body", "priority", "dueAt"],
+*   customFields: await customFields
+*     .listDefinitions("work_item")
+*     .orThrow(),
+* });
+* ```
+*/
+function entityForm(schema, options = {}) {
+	const specs = schema.spec.fields;
+	const keys = options.fields ?? Object.keys(specs).filter((key) => specs[key]?.readOnly !== true);
+	const custom = options.customFields ?? [];
+	const timeZone = options.timeZone ?? "UTC";
+	const fields = [...keys.flatMap((key) => {
+		const spec = specs[key];
+		return spec === void 0 ? [] : [entityField(key, spec, options.labels?.[key] ?? labelOf(key))];
+	}), ...custom.map((definition) => customField(definition, options.labels?.[definition.key]))];
+	const entityKeys = new Set(keys);
+	const customKeys = new Set(custom.map((definition) => definition.key));
+	return {
+		fields,
+		validate: async (values) => {
+			const errors = {};
+			const input = {};
+			const customValues = {};
+			for (const [key, value] of Object.entries(values)) {
+				const spec = entityKeys.has(key) ? specs[key] : void 0;
+				if (spec !== void 0 && !isBlank(value)) input[key] = typeof value === "string" && spec.array !== true ? coerce(spec, value.trim(), timeZone) : value;
+				else if (customKeys.has(key) && !isBlank(value)) customValues[key] = value;
+			}
+			for (const field of fields) if (field.source === "custom" && field.required && isBlank(values[field.key])) errors[field.key] = `${field.label} is required`;
+			const checked = await schema["~standard"].validate(input);
+			if (checked.issues !== void 0) for (const issue of checked.issues) {
+				const first = issue.path?.[0];
+				const part = typeof first === "object" ? first.key : first;
+				const key = typeof part === "string" ? part : "";
+				errors[key] ??= issue.message;
+			}
+			if (Object.keys(errors).length > 0 || checked.issues !== void 0) return {
+				ok: false,
+				errors
+			};
+			return {
+				ok: true,
+				input: checked.value,
+				custom: customValues
+			};
+		}
+	};
+}
+//#endregion
+export { can, countSection, createRecordController, defineRecordFeature, defineRecordList, defineSection, entityForm, findSectionWrite, loadMyWork, loadSections, loadTimeline, permissionFlags, plainData, recordCan, recordPermissionKeys, recordSubject, recordWriteInput, sectionCan, sectionEventMatches, sectionRowInput, sectionWrite, timelineSections };

package/dist/refusal-DXydjgsS.js

@@ -0,0 +1,64 @@
+import { r as dbErrorOf } from "./errors-03ysrOt4.js";
+import { o as problemResponse } from "./problem-BWElIgIb.js";
+import { t as defaultExpose } from "./respond-z_yfyitp.js";
+import { i as requireCaller } from "./kit-Ct4Z6GIO.js";
+//#region src/server/refusal.ts
+function isAalRefusal(error) {
+	return error.kind === "forbidden" && "required" in error && error.required === "aal2";
+}
+/** The page a refused caller is sent to, with `?next=`, when one is configured. */
+function refusalTarget(error, request, redirects) {
+	const page = error.kind === "unauthorized" ? redirects.signIn : isAalRefusal(error) ? redirects.mfa : void 0;
+	if (page === void 0) return;
+	const url = new URL(request.url);
+	const target = new URL(page, url);
+	if (target.pathname === url.pathname) return;
+	target.searchParams.set("next", `${url.pathname}${url.search}`);
+	return target;
+}
+/** A refusal as a redirect to `signIn` or `mfa`, else Problem Details. */
+function refusalResponse(error, request, redirects, expose) {
+	const target = refusalTarget(error, request, redirects);
+	if (target) return new Response(null, {
+		status: 303,
+		headers: { location: target.href }
+	});
+	return problemResponse(error, {
+		instance: new URL(request.url).pathname,
+		expose
+	});
+}
+/** The refusal for a caller `options` refuses, or `undefined` to let it through. */
+async function routeRefusal(locals, request, options) {
+	const caller = await requireCaller(locals.bs.auth, options, locals.tenant, options.authorizer, locals);
+	if (!("kind" in caller)) return;
+	return refusalResponse(caller, request, options, options.expose ?? defaultExpose());
+}
+/**
+* An `onError` mapper: a thrown `DbException` (or an error caused by a
+* `DbError`) becomes Problem Details; anything else is `undefined`, so the
+* framework's own handling stays.
+*/
+function errorResponse(cause, request, options = {}) {
+	const found = dbErrorOf(cause);
+	if (!found) return;
+	return problemResponse(found, {
+		instance: new URL(request.url).pathname,
+		expose: options.expose ?? defaultExpose()
+	});
+}
+/**
+* Reads the guard's view of a request's contributions; throws without
+* `withBetterSupabase`.
+*/
+function guardedLocals(contributions) {
+	const bs = "bs" in contributions ? contributions.bs : void 0;
+	if (typeof bs !== "object" || bs === null || !("auth" in bs)) throw new Error("better-supabase: the route guard needs withBetterSupabase(server) in the entries");
+	const tenant = "tenant" in contributions ? contributions.tenant : void 0;
+	return {
+		bs,
+		tenant: typeof tenant === "string" ? tenant : void 0
+	};
+}
+//#endregion
+export { routeRefusal as a, refusalTarget as i, guardedLocals as n, refusalResponse as r, errorResponse as t };

package/dist/refusal-efy5bZMd.d.ts

@@ -0,0 +1,32 @@
+import { r as AuthState } from "./resolve-CzUKTIMq.js";
+import { t as AnyAuthorizer } from "./authorizer-DFP3gHv8.js";
+import { c as ResourceLoaderContext, s as BlockRequireOptions } from "./kit-DKfbNTAA.js";
+//#region src/server/refusal.d.ts
+/** Where refused callers go instead of a Problem Details response. */
+interface RefusalRedirects {
+  /** Sign-in page for callers without a session; gets `?next=<path>`. */
+  readonly signIn?: string;
+  /** Second-factor page for users below the route's `aal`; gets `?next=<path>`. */
+  readonly mfa?: string;
+}
+/** What a route guard reads: the request's contributions. */
+interface GuardedLocals {
+  readonly bs: {
+    readonly auth: AuthState;
+  };
+  readonly tenant?: string | undefined;
+}
+interface RouteGuardOptions<C = unknown, P = unknown> extends BlockRequireOptions<C, P, boolean, unknown, GuardedLocals & ResourceLoaderContext<C, P>>, RefusalRedirects {
+  /**
+   * Include internal error messages in Problem Details. Defaults to development
+   * only.
+   */
+  readonly expose?: boolean;
+  /**
+   * Decides `permission`; without one, a route with a `permission` refuses
+   * every caller.
+   */
+  readonly authorizer?: AnyAuthorizer;
+}
+//#endregion
+export { RouteGuardOptions as n, RefusalRedirects as t };