better-supabase 0.8.0 → 0.10.0

package/dist/flags-sdk/index.js

@@ -0,0 +1,175 @@
+import { f as errorText } from "../block-helpers-BfVCR5Fc.js";
+import { a as flagContext, n as createFlagsProvider, r as evaluateFlag } from "../flags-CtSrkVuW.js";
+//#region src/flags-sdk/flags-sdk.ts
+function originOf(origin, key) {
+	return typeof origin === "function" ? origin(key) : origin?.replaceAll("{key}", encodeURIComponent(key));
+}
+/** Maps Flags SDK entities to the provider's evaluation context. */
+function flagContextOf(entities) {
+	const { user, organization, ...rest } = entities ?? {};
+	const roles = organization?.roles ?? [];
+	const contexts = Object.fromEntries(Object.entries(rest).flatMap(([name, entity]) => typeof entity?.id === "string" ? [[name, entity.id]] : []));
+	return {
+		...typeof user?.id === "string" && { targetingKey: user.id },
+		...typeof organization?.id === "string" && { tenant: organization.id },
+		...organization?.plans && { plans: organization.plans },
+		...roles.length > 0 && {
+			role: roles[0],
+			roles
+		},
+		...Object.keys(contexts).length > 0 && { contexts }
+	};
+}
+/** Whether `value` fits a flag of `type`; an `object` flag holds any JSON object or list. */
+function fitsType(value, type) {
+	return type === "object" ? typeof value === "object" && value !== null : typeof value === type;
+}
+/**
+* The flag's value for a declaration with `defaultValue`, or `undefined`
+* for the fallback: a missing variant or an unknown type always falls back.
+* A `null` value is served to a declaration whose default is `null` or
+* unset. Otherwise a declaration without a default takes any value, one
+* with a `null` default a value of the flag's type, and any other default a
+* value of its own `typeof`.
+*/
+async function valueOf(flag, defaultValue, context) {
+	if (!flag || flag.invalidType !== void 0) return;
+	const { value, found } = await evaluateFlag(flag, context);
+	if (!found) return;
+	if (value === null) return defaultValue === null || defaultValue === void 0 ? { value } : void 0;
+	if (defaultValue === void 0) return { value };
+	if (defaultValue === null) return fitsType(value, flag.type) ? { value } : void 0;
+	return typeof value === typeof defaultValue ? { value } : void 0;
+}
+const why = (flag) => flag === void 0 ? "it is missing" : flag.invalidType === void 0 ? "it has no such variant or has another type" : `it has the unknown type "${flag.invalidType}"`;
+/**
+* A Flags SDK adapter over the `flags` block. It evaluates rules, overrides,
+* custom contexts and rollouts like `flag_evaluation()`, from definitions it
+* caches for `ttl`. A flag that is missing, has an unknown type, has
+* another type than the declaration or fails to load gets the declaration's
+* `defaultValue`; without one, `decide` throws. A variant whose value is
+* `null` is served to a declaration whose `defaultValue` is `null` or unset.
+*/
+function betterSupabaseAdapter(options) {
+	const provider = options.provider ?? createFlagsProvider(options);
+	const adapterId = Symbol("better-supabase");
+	const { origin } = options;
+	const fallback = (key, defaultValue, why) => {
+		if (defaultValue === void 0) throw new Error(`Flag "${key}": ${why}, and it has no defaultValue`);
+		return defaultValue;
+	};
+	const make = () => ({
+		adapterId,
+		...origin !== void 0 && { origin: (key) => originOf(origin, key) },
+		async decide({ key, entities, defaultValue }) {
+			let flags;
+			try {
+				flags = await provider.definitions();
+			} catch (error) {
+				return fallback(key, defaultValue, errorText(error));
+			}
+			const flag = flags.find((entry) => entry.key === key);
+			const served = await valueOf(flag, defaultValue, flagContextOf(entities));
+			return served === void 0 ? fallback(key, defaultValue, why(flag)) : served.value;
+		},
+		async bulkDecide({ flags, entities }) {
+			const decided = {};
+			let definitions;
+			try {
+				definitions = new Map((await provider.definitions()).map((flag) => [flag.key, flag]));
+			} catch {
+				return decided;
+			}
+			const context = flagContextOf(entities);
+			for (const { key, defaultValue } of flags) {
+				const served = await valueOf(definitions.get(key), defaultValue, context);
+				if (served !== void 0) decided[key] = served.value;
+				else if (defaultValue !== void 0) decided[key] = defaultValue;
+			}
+			return decided;
+		}
+	});
+	return Object.assign(make, {
+		provider,
+		...origin !== void 0 && { origin }
+	});
+}
+/**
+* An `identify` for `flag()` declarations, built on `flagContext()`. Wrap it
+* in the Flags SDK's `dedupe` so it runs once per request.
+*/
+function createIdentify(options) {
+	return async (request) => {
+		const claims = await options.claims(request);
+		const tenant = await options.tenant?.(request, claims);
+		const contexts = await options.contexts?.(request, claims);
+		const context = flagContext({
+			jwtClaims: claims,
+			...tenant !== void 0 && { tenant },
+			...contexts !== void 0 && { contexts }
+		}, options);
+		const roles = context.roles ?? (context.role === void 0 ? void 0 : [context.role]);
+		const named = Object.entries(context.contexts ?? {}).filter(([name]) => name !== "user" && name !== "organization");
+		return {
+			...context.targetingKey !== void 0 && { user: { id: context.targetingKey } },
+			...context.tenant !== void 0 && { organization: {
+				id: context.tenant,
+				...context.plans && { plans: context.plans },
+				...roles && { roles }
+			} },
+			...Object.fromEntries(named.map(([name, id]) => [name, { id }]))
+		};
+	};
+}
+/**
+* A flag's variants as Flags SDK `options`, labelled by variant name. A
+* precomputed flag needs them to list its permutations.
+*/
+function flagOptions(definition) {
+	return Object.entries(definition.variants).map(([label, value]) => ({
+		value,
+		label
+	}));
+}
+/**
+* Flags Explorer data for every flag that isn't archived. Pass the adapter
+* factory or `{ provider, origin }`, and combine the result with other
+* providers' data through `mergeProviderData`. A failed load becomes a hint.
+*/
+async function getProviderData(options) {
+	let flags;
+	try {
+		flags = await options.provider.definitions();
+	} catch (error) {
+		return {
+			definitions: {},
+			hints: [{
+				key: "better-supabase/load-failed",
+				text: `Could not load the flag definitions: ${errorText(error)}`
+			}]
+		};
+	}
+	const definitions = {};
+	const hints = [];
+	for (const flag of flags) {
+		if (flag.archived === true) continue;
+		if (flag.invalidType !== void 0) hints.push({
+			key: "better-supabase/invalid-type",
+			text: `Flag "${flag.key}" has the unknown type "${flag.invalidType}", so it always serves its fallback`
+		});
+		const origin = originOf(options.origin, flag.key);
+		const updatedAt = flag.updatedAt === void 0 ? NaN : Date.parse(flag.updatedAt);
+		definitions[flag.key] = {
+			options: flagOptions(flag),
+			...flag.description !== void 0 && { description: flag.description },
+			...origin !== void 0 && { origin },
+			...Number.isFinite(updatedAt) && { updatedAt }
+		};
+	}
+	return {
+		definitions,
+		hints
+	};
+}
+//#endregion
+export { betterSupabaseAdapter, createIdentify, flagContextOf, flagOptions, getProviderData };

package/dist/form-definition-GVZTILhS.js

@@ -0,0 +1,311 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { n as blockOptions, r as option } from "./options-BMjcVuaI.js";
+//#region src/blocks/forms/options.ts
+const formsSqlOptions = blockOptions({
+	subjects: option.unknown(),
+	handlers: option.unknown(),
+	publicLimit: option.unknown(),
+	extraColumns: option.unknown()
+});
+const signaturesSqlOptions = blockOptions({
+	subjects: option.unknown(),
+	extraColumns: option.unknown()
+});
+//#endregion
+//#region src/core/contracts/form-definition.ts
+const FORM_FIELD_TYPES = [
+	"text",
+	"textarea",
+	"email",
+	"url",
+	"number",
+	"integer",
+	"date",
+	"bool",
+	"consent",
+	"option",
+	"multi",
+	"json"
+];
+/** 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}$"
+							}
+						}
+					}
+				}
+			}
+		}
+	} }
+};
+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 };
+		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`), and a choice field without options. Empty when
+* the definition is fine.
+*/
+function formDefinitionProblems(definition) {
+	const problems = [];
+	const steps = /* @__PURE__ */ new Set();
+	const fields = /* @__PURE__ */ new Set();
+	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`);
+		}
+	}
+	return problems;
+}
+//#endregion
+export { formDefinitionProblems as a, formsSqlOptions as c, FORM_SCHEMA_DIALECT as i, signaturesSqlOptions as l, FORM_FIELD_TYPES as n, formSchema as o, FORM_MAX_LENGTH as r, isFormDefinition as s, FORM_DEFINITION_SCHEMA as t };

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

@@ -0,0 +1,95 @@
+//#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";
+declare const FORM_FIELD_TYPES: readonly FormFieldType[];
+/**
+ * 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;
+}
+interface FormStep {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly showIf?: FormCondition;
+  readonly fields: readonly FormField[];
+}
+interface FormDefinition {
+  readonly steps: readonly FormStep[];
+}
+/** 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`), and a choice field without options. Empty when
+ * the definition is fine.
+ */
+declare function formDefinitionProblems(definition: FormDefinition): readonly string[];
+//#endregion
+export { FormDefinition as a, FormJson as c, FormStep as d, formDefinitionProblems as f, FormCondition as i, FormJsonSchema as l, isFormDefinition as m, FORM_FIELD_TYPES as n, FormField as o, formSchema as p, FORM_SCHEMA_DIALECT as r, FormFieldType as s, FORM_DEFINITION_SCHEMA as t, FormOption as u };

package/dist/format-CNwSjXUU.d.ts

@@ -0,0 +1,70 @@
+import { t as ApiModel } from "./model-lUafmeBQ.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-C2oL4OaO.d.ts

@@ -0,0 +1,26 @@
+import { a as AnyModels, i as AnyFunctions } from "./types-BO8lVTun.js";
+import { s as ServerOptions } from "./server-types-fXwJoFjt.js";
+import { t as AuthSession } from "./view-SuASaomx.js";
+import { n as SessionEntryConfig } from "./session-Djo5t4KQ.js";
+import { n as BetterSupabaseContributions } from "./composite-DMMA_Whg.js";
+import { t as RefusalRedirects } from "./refusal-Bdr1k47u.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> = BetterSupabaseContributions<M, F, E, C, P> & {
+  /** The caller as plain data, safe to return from a loader to the browser. */
+  readonly session: AuthSession<C, P>;
+};
+//#endregion
+export { FrameworkOptions as n, FrameworkLocals as t };