better-supabase 0.12.0 → 0.14.0

package/dist/form-definition-BTpM_tz1.js

@@ -0,0 +1,363 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+//#region src/core/contracts/form-definition.ts
+const FORM_FIELD_TYPES = [
+	"text",
+	"textarea",
+	"email",
+	"url",
+	"number",
+	"integer",
+	"date",
+	"bool",
+	"consent",
+	"option",
+	"multi",
+	"json",
+	"nps"
+];
+/** The field types that can't have a `correct` answer. */
+const UNSCORED_FIELD_TYPES = [
+	"consent",
+	"json",
+	"nps"
+];
+/** The highest answer to an `nps` field; the lowest is 0. */
+const NPS_MAX = 10;
+/** The dialect every generated schema declares (`SPEC_PINS.jsonSchema`). */
+const FORM_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/** The longest answer a field takes when it sets no `maxLength`. */
+const FORM_MAX_LENGTH = {
+	text: 500,
+	textarea: 1e4,
+	email: 320,
+	url: 2e3
+};
+const KEY = {
+	type: "string",
+	pattern: "^[a-z][a-zA-Z0-9_]{0,62}$"
+};
+const CONDITION = {
+	type: "object",
+	required: ["field"],
+	minProperties: 2,
+	maxProperties: 2,
+	additionalProperties: false,
+	properties: {
+		field: KEY,
+		equals: {},
+		in: {
+			type: "array",
+			minItems: 1,
+			maxItems: 500
+		},
+		filled: { const: true }
+	}
+};
+const TEXT = (max) => ({
+	type: "string",
+	maxLength: max
+});
+/**
+* The shape of a definition. It uses only keywords whose meaning is the same in
+* drafts 7 and 2020-12, because pg_jsonschema validates by draft 7 rules.
+*/
+const FORM_DEFINITION_SCHEMA = {
+	$schema: FORM_SCHEMA_DIALECT,
+	type: "object",
+	required: ["steps"],
+	additionalProperties: false,
+	properties: {
+		steps: {
+			type: "array",
+			minItems: 1,
+			maxItems: 50,
+			items: {
+				type: "object",
+				required: ["key", "fields"],
+				additionalProperties: false,
+				properties: {
+					key: KEY,
+					title: TEXT(200),
+					description: TEXT(2e3),
+					showIf: CONDITION,
+					fields: {
+						type: "array",
+						minItems: 1,
+						maxItems: 200,
+						items: {
+							type: "object",
+							required: ["key"],
+							additionalProperties: false,
+							properties: {
+								key: KEY,
+								label: {
+									type: "string",
+									minLength: 1,
+									maxLength: 200
+								},
+								type: { enum: [...FORM_FIELD_TYPES] },
+								required: { type: "boolean" },
+								help: TEXT(1e3),
+								placeholder: TEXT(200),
+								options: {
+									type: "array",
+									minItems: 1,
+									maxItems: 500,
+									items: {
+										type: "object",
+										required: ["value", "label"],
+										additionalProperties: false,
+										properties: {
+											value: {
+												type: "string",
+												minLength: 1,
+												maxLength: 200
+											},
+											label: {
+												type: "string",
+												minLength: 1,
+												maxLength: 200
+											}
+										}
+									}
+								},
+								min: { type: "number" },
+								max: { type: "number" },
+								minLength: {
+									type: "integer",
+									minimum: 0
+								},
+								maxLength: {
+									type: "integer",
+									minimum: 1
+								},
+								pattern: TEXT(500),
+								showIf: CONDITION,
+								customField: {
+									type: "string",
+									pattern: "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+								},
+								correct: {},
+								points: {
+									type: "number",
+									minimum: 0,
+									maximum: 1e4
+								}
+							}
+						}
+					}
+				}
+			}
+		},
+		scoring: {
+			type: "object",
+			additionalProperties: false,
+			properties: { passMark: {
+				type: "number",
+				minimum: 0,
+				maximum: 100
+			} }
+		}
+	}
+};
+const EMPTY_VALUES = [
+	null,
+	"",
+	[]
+];
+/** The schema a condition holds under, as an `if`. */
+function conditionSchema(condition) {
+	const { field } = condition;
+	const value = "equals" in condition ? { const: condition.equals } : "in" in condition ? { enum: [...condition.in] } : { not: { enum: [...EMPTY_VALUES] } };
+	return {
+		properties: { [field]: value },
+		required: [field]
+	};
+}
+const defined = (entries) => Object.fromEntries(Object.entries(entries).filter((entry) => entry[1] !== void 0));
+/** The schema of one field's answer. */
+function fieldSchema(field) {
+	const type = field.type;
+	if (type === void 0) throw new TypeError(`form field ${field.key} has no type: publish the version to resolve its customField`);
+	const values = (field.options ?? []).map((option) => option.value);
+	const annotations = defined({
+		title: field.label,
+		description: field.help
+	});
+	const maxLength = (fallback) => field.maxLength ?? fallback;
+	const floor = field.required === true ? 1 : void 0;
+	switch (type) {
+		case "text":
+		case "textarea": return {
+			type: "string",
+			maxLength: maxLength(FORM_MAX_LENGTH[type]),
+			...defined({
+				minLength: field.minLength ?? floor,
+				pattern: field.pattern
+			}),
+			...annotations
+		};
+		case "email": return {
+			type: "string",
+			format: "email",
+			maxLength: FORM_MAX_LENGTH.email,
+			...annotations
+		};
+		case "url": return {
+			type: "string",
+			format: "uri",
+			maxLength: FORM_MAX_LENGTH.url,
+			...annotations
+		};
+		case "number":
+		case "integer": return {
+			type,
+			...defined({
+				minimum: field.min,
+				maximum: field.max
+			}),
+			...annotations
+		};
+		case "date": return {
+			type: "string",
+			format: "date",
+			...annotations
+		};
+		case "bool": return {
+			type: "boolean",
+			...annotations
+		};
+		case "consent": return {
+			type: "boolean",
+			const: true,
+			...annotations
+		};
+		case "option": return {
+			type: "string",
+			enum: values,
+			...annotations
+		};
+		case "multi": return {
+			type: "array",
+			items: {
+				type: "string",
+				enum: values
+			},
+			uniqueItems: true,
+			...defined({
+				minItems: field.min ?? floor,
+				maxItems: field.max
+			}),
+			...annotations
+		};
+		case "json": return { ...annotations };
+		case "nps": return {
+			type: "integer",
+			minimum: 0,
+			maximum: 10,
+			...annotations
+		};
+		default: throw new TypeError(`unknown form field type ${String(type)}`);
+	}
+}
+/**
+* The JSON Schema 2020-12 a version's submissions validate against. A required
+* field with a `showIf` (its own or its step's) is required only while the
+* condition holds. Like `FORM_DEFINITION_SCHEMA`, it keeps to the keywords
+* drafts 7 and 2020-12 share.
+*/
+function formSchema(definition) {
+	const properties = {};
+	const required = [];
+	const conditional = [];
+	for (const step of definition.steps) for (const field of step.fields) {
+		properties[field.key] = fieldSchema(field);
+		if (field.required !== true) continue;
+		const conditions = [step.showIf, field.showIf].filter((condition) => condition !== void 0).map(conditionSchema);
+		if (conditions.length === 0) {
+			required.push(field.key);
+			continue;
+		}
+		conditional.push({
+			if: conditions.length === 1 ? conditions[0] : { allOf: conditions },
+			then: { required: [field.key] }
+		});
+	}
+	return {
+		$schema: FORM_SCHEMA_DIALECT,
+		type: "object",
+		properties,
+		additionalProperties: false,
+		...required.length > 0 ? { required } : {},
+		...conditional.length > 0 ? { allOf: conditional } : {}
+	};
+}
+/**
+* Whether `value` has a definition's outline: steps with a key and fields with
+* a key. `FORM_DEFINITION_SCHEMA` checks the rest.
+*/
+function isFormDefinition(value) {
+	return isRecord(value) && Array.isArray(value["steps"]) && value["steps"].every((step) => isRecord(step) && typeof step["key"] === "string" && Array.isArray(step["fields"]) && step["fields"].every((field) => isRecord(field) && typeof field["key"] === "string"));
+}
+/**
+* What the definition's shape can't say: duplicate keys, conditions on a field
+* that isn't earlier in the form, a field without a label and type (and no
+* `customField`), a choice field without options, and a `correct` answer the
+* field can't take (or `points` or `scoring` without one). Empty when the
+* definition is fine.
+*/
+function formDefinitionProblems(definition) {
+	const problems = [];
+	const steps = /* @__PURE__ */ new Set();
+	const fields = /* @__PURE__ */ new Set();
+	let scored = false;
+	const refers = (condition, where) => {
+		if (condition !== void 0 && !fields.has(condition.field)) problems.push(`${where}: showIf names ${condition.field}, which isn't an earlier field`);
+	};
+	for (const step of definition.steps) {
+		if (steps.has(step.key)) problems.push(`step ${step.key} is listed twice`);
+		steps.add(step.key);
+		refers(step.showIf, `step ${step.key}`);
+		for (const field of step.fields) {
+			if (fields.has(field.key)) problems.push(`field ${field.key} is listed twice`);
+			refers(field.showIf, `field ${field.key}`);
+			fields.add(field.key);
+			if (field.customField === void 0 && (field.label === void 0 || field.type === void 0)) problems.push(`field ${field.key} needs a label and a type, or a customField`);
+			if (field.customField === void 0 && (field.type === "option" || field.type === "multi") && (field.options?.length ?? 0) === 0) problems.push(`field ${field.key} needs options`);
+			problems.push(...scoringProblems(field));
+			scored ||= field.correct !== void 0;
+		}
+	}
+	if (definition.scoring !== void 0 && !scored) problems.push("scoring needs a field with a correct answer");
+	return problems;
+}
+/** Whether `correct` is an answer a field of `type` with these choices takes. */
+function correctFits(type, correct, values) {
+	switch (type) {
+		case "text":
+		case "textarea":
+		case "email":
+		case "url":
+		case "date": return typeof correct === "string";
+		case "number": return typeof correct === "number";
+		case "integer": return typeof correct === "number" && Number.isInteger(correct);
+		case "bool": return typeof correct === "boolean";
+		case "option": return typeof correct === "string" && values.includes(correct);
+		case "multi": return Array.isArray(correct) && correct.length > 0 && correct.every((value) => typeof value === "string" && values.includes(value));
+		case "consent":
+		case "json":
+		case "nps": return false;
+		default: throw new TypeError(`unknown form field type ${String(type)}`);
+	}
+}
+/** A field's `correct` and `points` problems, as `form_resolve` reports them. */
+function scoringProblems(field) {
+	const { correct, type } = field;
+	if (correct === void 0) return field.points === void 0 ? [] : [`field ${field.key}: points need a correct answer`];
+	if (correct === null) return [`field ${field.key}: correct can't be null`];
+	if (type === void 0) return [];
+	if (UNSCORED_FIELD_TYPES.includes(type)) return [`field ${field.key}: a ${type} field can't have a correct answer`];
+	return correctFits(type, correct, (field.options ?? []).map((option) => option.value)) ? [] : [`field ${field.key}: correct isn't an answer the field takes`];
+}
+//#endregion
+export { NPS_MAX as a, formSchema as c, FORM_SCHEMA_DIALECT as i, isFormDefinition as l, FORM_FIELD_TYPES as n, UNSCORED_FIELD_TYPES as o, FORM_MAX_LENGTH as r, formDefinitionProblems as s, FORM_DEFINITION_SCHEMA as t };

package/dist/form-definition-BjEtH8BT.d.ts

@@ -0,0 +1,119 @@
+//#region src/core/contracts/form-definition.d.ts
+/**
+ * The forms block's definition format and the JSON Schema each published
+ * version gets. The SQL module embeds `FORM_DEFINITION_SCHEMA` and builds the
+ * same answer schema as `formSchema`, so the two can't drift.
+ */
+/** A JSON value in a definition or an answer. */
+type FormJson = string | number | boolean | null | readonly FormJson[] | {
+  readonly [key: string]: FormJson;
+};
+/** A JSON Schema document, as the generator writes it. */
+type FormJsonSchema = {
+  readonly [key: string]: FormJson;
+};
+type FormFieldType = "text" | "textarea" | "email" | "url" | "number" | "integer" | "date" | "bool" | "consent" | "option" | "multi" | "json" | "nps";
+declare const FORM_FIELD_TYPES: readonly FormFieldType[];
+/** The field types that can't have a `correct` answer. */
+declare const UNSCORED_FIELD_TYPES: readonly FormFieldType[];
+/** The highest answer to an `nps` field; the lowest is 0. */
+declare const NPS_MAX = 10;
+/**
+ * When a step or field shows: an earlier field's answer `equals` a value, is
+ * one of `in`, or is `filled` (present and not `null`, `""` or `[]`).
+ */
+type FormCondition = {
+  readonly field: string;
+  readonly equals: FormJson;
+} | {
+  readonly field: string;
+  readonly in: readonly FormJson[];
+} | {
+  readonly field: string;
+  readonly filled: true;
+};
+interface FormOption {
+  readonly value: string;
+  readonly label: string;
+}
+interface FormField {
+  /** The answer's key: a letter, then letters, digits or `_`. */
+  readonly key: string;
+  readonly label?: string;
+  readonly type?: FormFieldType;
+  readonly required?: boolean;
+  readonly help?: string;
+  readonly placeholder?: string;
+  /** The choices of an `option` or `multi` field. */
+  readonly options?: readonly FormOption[];
+  /** The bounds of a number, or the number of choices of a `multi` field. */
+  readonly min?: number;
+  readonly max?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  readonly pattern?: string;
+  readonly showIf?: FormCondition;
+  /**
+   * A custom-fields definition id. Publishing copies its label, type, options
+   * and `required` into the field; the field's own keys win.
+   */
+  readonly customField?: string;
+  /**
+   * The answer that earns the field's points: a choice's value, an array of
+   * values for `multi` (in any order), or the exact value of the other types.
+   * Text compares without case and surrounding spaces. Publishing moves it to
+   * an answer key respondents can't read.
+   */
+  readonly correct?: FormJson;
+  /** What a correct answer earns. Default 1; needs `correct`. */
+  readonly points?: number;
+}
+interface FormStep {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly showIf?: FormCondition;
+  readonly fields: readonly FormField[];
+}
+/** How a scored form grades a submission. */
+interface FormScoring {
+  /**
+   * The share of the points a submission needs to pass, from 0 to 100. Without
+   * it a scored submission gets a score but no pass or fail.
+   */
+  readonly passMark?: number;
+}
+interface FormDefinition {
+  readonly steps: readonly FormStep[];
+  /** Needs a field with a `correct` answer. */
+  readonly scoring?: FormScoring;
+}
+/** The dialect every generated schema declares (`SPEC_PINS.jsonSchema`). */
+declare const FORM_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/**
+ * The shape of a definition. It uses only keywords whose meaning is the same in
+ * drafts 7 and 2020-12, because pg_jsonschema validates by draft 7 rules.
+ */
+declare const FORM_DEFINITION_SCHEMA: FormJsonSchema;
+/**
+ * The JSON Schema 2020-12 a version's submissions validate against. A required
+ * field with a `showIf` (its own or its step's) is required only while the
+ * condition holds. Like `FORM_DEFINITION_SCHEMA`, it keeps to the keywords
+ * drafts 7 and 2020-12 share.
+ */
+declare function formSchema(definition: FormDefinition): FormJsonSchema;
+/**
+ * Whether `value` has a definition's outline: steps with a key and fields with
+ * a key. `FORM_DEFINITION_SCHEMA` checks the rest.
+ */
+declare function isFormDefinition(value: unknown): value is FormDefinition;
+/**
+ * What the definition's shape can't say: duplicate keys, conditions on a field
+ * that isn't earlier in the form, a field without a label and type (and no
+ * `customField`), a choice field without options, and a `correct` answer the
+ * field can't take (or `points` or `scoring` without one). Empty when the
+ * definition is fine.
+ */
+declare function formDefinitionProblems(definition: FormDefinition): readonly string[];
+//#endregion
+export { isFormDefinition as _, FormDefinition as a, FormJson as c, FormScoring as d, FormStep as f, formSchema as g, formDefinitionProblems as h, FormCondition as i, FormJsonSchema as l, UNSCORED_FIELD_TYPES as m, FORM_FIELD_TYPES as n, FormField as o, NPS_MAX as p, FORM_SCHEMA_DIALECT as r, FormFieldType as s, FORM_DEFINITION_SCHEMA as t, FormOption as u };

package/dist/format-AYHceC2m.d.ts

@@ -0,0 +1,79 @@
+import { t as ApiModel } from "./model-Btl8X9cs.js";
+//#region src/spec/format.d.ts
+/**
+ * How a version of a format is supported. `preview` follows a draft and is
+ * never a default.
+ */
+type VersionStatus = "stable" | "legacy" | "preview";
+interface FormatVersion {
+  /** The exact version or commit the output follows (a `SPEC_PINS` value). */
+  readonly pin: string;
+  readonly status: VersionStatus;
+}
+type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A finding from building, lowering or checking a document. `code` is stable:
+ * tools and `--fail-on` read it, and a retired code stays reserved.
+ */
+interface SpecDiagnostic {
+  readonly code: string;
+  readonly severity: DiagnosticSeverity;
+  readonly message: string;
+  /** A JSON Pointer into the document or the model, when there is one. */
+  readonly pointer?: string;
+}
+interface LowerContext {
+  /** Records a diagnostic; lowering continues. */
+  report(diagnostic: SpecDiagnostic): void;
+}
+/**
+ * The plugin contract every document format implements, the first-party ones
+ * included (API v1). `lower` is pure: it reads the model and returns a new
+ * document, so the same model renders to every version. `Docs` maps each
+ * version to its document type, so `transform` hooks can switch on the version;
+ * it defaults to `Doc` for every version.
+ */
+interface DocumentFormat<Id extends string = string, V extends string = string, Doc = unknown, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>> {
+  readonly apiVersion: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: V;
+  lower(model: ApiModel, version: V, ctx: LowerContext): Doc;
+  /**
+   * Semantic checks a schema cannot express (unique ids, resolvable
+   * references).
+   */
+  lint?(doc: Doc, version: V): readonly SpecDiagnostic[];
+  /** Default file name for a version, e.g. `openapi.json`. */
+  fileName(version: V): string;
+  /** Phantom carrying the per-version document types. */
+  readonly "~documents"?: Docs;
+}
+type AnyDocumentFormat = DocumentFormat<string, any, any, any>;
+type VersionOf<F> = F extends DocumentFormat<string, infer V> ? V : never;
+type DocumentOf<F> = F extends DocumentFormat<string, any, infer D, any> ? D : never;
+/**
+ * What a `transform` hook receives: the document with its format and version, a
+ * union discriminated by `version`.
+ */
+type RenderedOf<F> = F extends DocumentFormat<infer Id, infer V, any, infer Docs> ? { [K in V]: {
+  readonly format: Id;
+  readonly version: K;
+  readonly document: K extends keyof Docs ? Docs[K] : never;
+}; }[V] : never;
+/**
+ * Identity helper that fixes `apiVersion` and checks that the default version
+ * exists.
+ */
+declare function defineDocumentFormat<const Id extends string, const V extends string, Doc, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>>(format: {
+  readonly apiVersion?: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: NoInfer<V>;
+  lower(model: ApiModel, version: NoInfer<V>, ctx: LowerContext): Doc;
+  lint?(doc: Doc, version: NoInfer<V>): readonly SpecDiagnostic[];
+  fileName(version: NoInfer<V>): string;
+  readonly "~documents"?: Docs;
+}): DocumentFormat<Id, V, Doc, Docs>;
+//#endregion
+export { FormatVersion as a, SpecDiagnostic as c, defineDocumentFormat as d, DocumentOf as i, VersionOf as l, DiagnosticSeverity as n, LowerContext as o, DocumentFormat as r, RenderedOf as s, AnyDocumentFormat as t, VersionStatus as u };

package/dist/framework-CXoyWGgd.js

@@ -0,0 +1,57 @@
+import { n as toSession } from "./view-BtgqxQLM.js";
+import { t as withBetterSupabase } from "./composite-Dv6o2BSw.js";
+//#region src/server/framework.ts
+/**
+* Every caller: the framework factories guard per loader, action or route
+* instead.
+*/
+const EVERY_CALLER = [
+	"user",
+	"anonymous",
+	"anon",
+	"service",
+	"apiKey"
+];
+/**
+* The `withBetterSupabase` entry the framework factories run, admitting every
+* caller.
+*/
+function frameworkEntry(server, options, expose) {
+	return withBetterSupabase(server, {
+		refresh: options.refresh ?? "navigation",
+		allow: EVERY_CALLER,
+		expose,
+		...options.checkSession === void 0 ? {} : { checkSession: options.checkSession },
+		...options.cookieScopes === void 0 ? {} : { cookieScopes: options.cookieScopes },
+		...options.encode === void 0 ? {} : { encode: options.encode },
+		...options.waitUntil === void 0 ? {} : { waitUntil: options.waitUntil }
+	});
+}
+/** The contributions plus the serializable `session`. */
+function localsOf(contributions) {
+	const base = contributions;
+	return {
+		...base,
+		session: toSession(base.bs.auth)
+	};
+}
+function isWaitUntilHost(value) {
+	return typeof value === "object" && value !== null && "waitUntil" in value && typeof value.waitUntil === "function";
+}
+/** `platform.context.waitUntil` on Cloudflare, `platform.waitUntil` elsewhere. */
+function platformWaitUntil(platform) {
+	if (typeof platform !== "object" || platform === null) return;
+	const context = "context" in platform ? platform.context : platform;
+	if (!isWaitUntilHost(context)) return;
+	return (promise) => {
+		context.waitUntil(promise);
+	};
+}
+/** The form body as `FormData`, JSON as a value, nothing as `undefined`. */
+async function actionInput(request) {
+	const type = request.headers.get("content-type") ?? "";
+	if (type.includes("application/json")) return request.json();
+	if (type.includes("form-data") || type.includes("application/x-www-form-urlencoded")) return request.formData();
+}
+//#endregion
+export { platformWaitUntil as a, localsOf as i, actionInput as n, frameworkEntry as r, EVERY_CALLER as t };

package/dist/framework-FxfJpyoF.d.ts

@@ -0,0 +1,41 @@
+import { M as AnyFunctions, N as AnyModels } from "./executor-CPyrQdjh.js";
+import { t as AuthSession } from "./view-2_I-2ukO.js";
+import { c as ServerOptions } from "./server-types-BOs-eFpo.js";
+import { n as SessionEntryConfig } from "./session-BgsOPGZs.js";
+import { n as BetterSupabaseContributions } from "./composite-KllwFim2.js";
+import { c as ResourceLoaderContext } from "./kit-DKfbNTAA.js";
+import { t as RefusalRedirects } from "./refusal-efy5bZMd.js";
+//#region src/server/framework.d.ts
+/**
+ * What the framework factories (`createSvelteKit`, `createReactRouter`,
+ * `createTanStackStart`) take.
+ */
+interface FrameworkOptions extends ServerOptions, RefusalRedirects, Pick<SessionEntryConfig, "checkSession" | "cookieScopes" | "encode"> {
+  /**
+   * When the middleware refreshes an expired session cookie. Defaults to
+   * `'navigation'`: page loads, client navigations and form posts.
+   */
+  readonly refresh?: SessionEntryConfig["refresh"];
+  /**
+   * Include internal error messages in Problem Details. Defaults to development
+   * only.
+   */
+  readonly exposeErrors?: boolean;
+  /**
+   * Keeps the invocation alive for event sink sends, e.g. the Workers
+   * `ctx.waitUntil`.
+   */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** The keys the framework factories put on `locals` or `context`. */
+type FrameworkLocals<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = BetterSupabaseContributions<M, F, E, C, P, B> & {
+  /** The caller as plain data, safe to return from a loader to the browser. */
+  readonly session: AuthSession<C, P>;
+};
+/**
+ * What a `resource` loader gets in a framework adapter: the locals, with the
+ * checked tenant.
+ */
+type LocalsResource<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> = FrameworkLocals<M, F, E, C, P, B> & ResourceLoaderContext<C, P>;
+//#endregion
+export { FrameworkOptions as n, LocalsResource as r, FrameworkLocals as t };

package/dist/function-contract-pEmsaUIf.js

@@ -0,0 +1,8 @@
+//#region src/core/function-contract.ts
+/**
+* The key `defineFunction` stores its schemas under, so `better-supabase/spec`
+* can read them without importing `edge`.
+*/
+const FUNCTION_DESCRIPTOR = Symbol.for("better-supabase.function");
+//#endregion
+export { FUNCTION_DESCRIPTOR as t };