better-supabase 0.14.0 → 0.15.0

package/dist/flows/index.d.ts

@@ -1,247 +0,0 @@
-import { f as Result, t as AsyncResult } from "../result-C6jDfedy.js";
-import { H as InboxEventData, tt as SchedulingEventData } from "../events-DbLjvxDX.js";
-import { S as QuoteEventData, t as ApplicationEventData } from "../block-events-records-BGVyoz57.js";
-import { c as EmployeeInput, i as Employee } from "../employees-Dwyvxs4r.js";
-import { n as EngagementInput, r as EngagementSubject, t as Engagement } from "../engagements-CsJhf2OM.js";
-import { i as Conversation } from "../types-DkPE7yd2.js";
-import { o as WorkItem, u as WorkItemInput } from "../work-items-Cnntm8ij.js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/flows/flow.d.ts
-/** A record a flow reads from or creates: its subject type and id. */
-interface FlowRef {
-  readonly type: string;
-  readonly id: string;
-}
-/**
- * An event a flow starts from. An outbox event fits; a job keeps only these
- * fields, so they stay JSON.
- */
-interface FlowEvent<P = unknown> {
-  readonly id: string;
-  readonly type: string;
-  readonly payload: P;
-  readonly subject?: string | null;
-  readonly tenant?: string | null;
-  readonly actorId?: string | null;
-}
-/** The part of the relations block a flow uses; `blocks.relations` fits. */
-interface FlowRelations {
-  link(source: FlowRef, target: FlowRef, input: {
-    readonly kind: "created_from";
-  }): PromiseLike<Result<unknown>>;
-  convertedInto(origin: FlowRef, intoType: string): PromiseLike<Result<string | undefined>>;
-}
-/** The clients every flow gets; a flow names the other blocks it needs. */
-interface FlowClients {
-  readonly relations: FlowRelations;
-}
-/** What a flow's hooks receive for one event. */
-interface FlowContext<C, P = unknown> {
-  readonly clients: C;
-  /** The organization the event belongs to. */
-  readonly tenant: string;
-  readonly event: FlowEvent<P>;
-  /** The record the event is about, from `source`. */
-  readonly source: FlowRef;
-}
-interface FlowSpec<C, P, S, T> {
-  /** Unique among the flows of one `createFlows`; it keys the job dedupe. */
-  readonly name: string;
-  /** The event type, or types, that start the flow. */
-  readonly on: string | readonly string[];
-  /** The subject type the flow creates, such as `work_item`. */
-  readonly target: string;
-  /** The record the event is about; `undefined` skips the event. */
-  readonly source: (event: FlowEvent<P>) => FlowRef | undefined;
-  /** Reads what `map` needs, such as the source record. */
-  readonly load?: (context: FlowContext<C, P>) => PromiseLike<Result<S>>;
-  /**
-   * The target block's input schema (`block.schemas.<entity>.input`): the
-   * mapped value must pass it before `create` runs.
-   */
-  readonly input?: StandardSchemaV1<T>;
-  /** Turns what `load` read into the target block's input. */
-  readonly map: (loaded: S, context: FlowContext<C, P>) => T;
-  /** Creates the target record and returns its id. */
-  readonly create: (input: T, context: FlowContext<C, P>) => PromiseLike<Result<{
-    readonly id: string;
-  }>>;
-  /**
-   * The target block records the `created_from` link itself, as
-   * `employees.fromApplication` does.
-   */
-  readonly linksItself?: boolean;
-}
-/** A flow from `defineFlow` (`apiVersion: 1`). */
-interface Flow<C extends FlowClients = FlowClients, P = unknown, S = unknown, T = unknown> extends FlowSpec<C, P, S, T> {
-  readonly apiVersion: 1;
-}
-type Varies = any;
-/** A flow over any payload, loaded value and input, for `createFlows`. */
-type AnyFlow<C extends FlowClients = FlowClients> = Flow<C, Varies, Varies, Varies>;
-/**
- * Declares a flow: when an event of type `on` arrives, read the source record,
- * map it to the target block's input and create the target record, once. The
- * new record is linked `created_from` the source, so `relations.lineage` finds
- * the chain and a second run returns the first record.
- */
-export declare function defineFlow<C extends FlowClients, P = unknown, S = undefined, T = unknown>(spec: FlowSpec<C, P, S, T>): Flow<C, P, S, T>;
-/** What `run` did with one event. */
-type FlowOutcome = {
-  readonly status: "created";
-  readonly target: FlowRef;
-} | {
-  readonly status: "exists";
-  readonly target: FlowRef;
-} | {
-  readonly status: "skipped";
-};
-/** A queued flow run: the flow's name and the event, as JSON. */
-interface FlowJob {
-  readonly flow: string;
-  readonly event: FlowEvent;
-}
-interface FlowsOptions<C extends FlowClients> {
-  /** The flows to turn on. A built-in runs only when it is listed here. */
-  readonly flows: readonly AnyFlow<C>[];
-  /**
-   * The block clients for one tenant, such as `createBlocks` with `tenant: ()
-   * => tenant` over a service connection.
-   */
-  readonly clients: (tenant: string, event: FlowEvent) => C | PromiseLike<C>;
-  /**
-   * Queues each run as a job instead of running it in the outbox consumer, such
-   * as `(job, dedupeKey) => jobs.enqueueOnce("flows", job, { dedupeKey })`. The
-   * key is `flow:<name>:<event id>`, so a redelivered event queues once.
-   */
-  readonly enqueue?: (job: FlowJob, dedupeKey: string) => PromiseLike<Result<unknown>>;
-  /** Receives each run's outcome. */
-  readonly onOutcome?: (flow: string, event: FlowEvent, outcome: FlowOutcome) => void;
-}
-interface Flows {
-  /** The flows that start on an event type. */
-  matching(type: string): readonly string[];
-  /** Runs one flow for one event, once: a second run returns `exists`. */
-  run(flow: string, event: FlowEvent): AsyncResult<FlowOutcome>;
-  /**
-   * The outbox consumer, for `outbox.consume("flows", flows.sink())`. It throws
-   * when a run or an enqueue fails, so the outbox delivers the event again; the
-   * runs that already finished find their record and return `exists`.
-   */
-  sink(): (events: readonly FlowEvent[]) => Promise<void>;
-  /** The job handler for the queue `enqueue` writes to. */
-  handler(): (payload: FlowJob) => Promise<void>;
-}
-/**
- * Turns flows on: an outbox consumer that runs, or queues, every flow whose
- * `on` matches an event, and the job handler that runs the queued ones.
- *
- * ```ts
- * const flows = createFlows({
- *   flows: [conversationToWorkItem()],
- *   clients: (tenant) => blocksFor(tenant),
- * });
- * await outbox.consume("flows", flows.sink());
- * ```
- */
-export declare function createFlows<C extends FlowClients>(options: FlowsOptions<C>): Flows;
-//#endregion
-//#region src/flows/built-ins.d.ts
-type Created = PromiseLike<Result<{
-  readonly id: string;
-}>>;
-/** The subject types a built-in reads and writes, when the app renamed them. */
-interface BuiltInFlowOptions {
-  /** The event that starts the flow. */
-  readonly on?: string;
-  /** The subject type of the record the event is about. */
-  readonly sourceType?: string;
-  /** The subject type the flow creates. */
-  readonly targetType?: string;
-}
-/** `blocks.inbox` and `blocks.workItems`, for `conversationToWorkItem`. */
-interface ConversationToWorkItemClients extends FlowClients {
-  readonly inbox: {
-    readonly conversations: {
-      get(conversationId: string): PromiseLike<Result<Conversation | null>>;
-    };
-  };
-  readonly workItems: {
-    create(organizationId: string, input: WorkItemInput, assigneeIds?: readonly string[]): PromiseLike<Result<WorkItem>>;
-  };
-}
-interface ConversationToWorkItemOptions extends BuiltInFlowOptions {
-  /**
-   * The work item for a conversation. Default: its subject or preview as the
-   * title.
-   */
-  readonly map?: (conversation: Conversation, context: FlowContext<ConversationToWorkItemClients, InboxEventData>) => WorkItemInput;
-  /** Assigns the work item to the conversation's assignee. Default: true. */
-  readonly assign?: boolean;
-}
-/**
- * A work item for each conversation the inbox opens, linked `created_from` the
- * conversation. The mapped input passes the work item input schema.
- */
-export declare function conversationToWorkItem(options?: ConversationToWorkItemOptions): Flow<ConversationToWorkItemClients, InboxEventData, Conversation, WorkItemInput>;
-/** `blocks.employees`, for `applicationToEmployee`. */
-interface ApplicationToEmployeeClients extends FlowClients {
-  readonly employees: {
-    fromApplication(applicationId: string, overrides?: Partial<EmployeeInput>): PromiseLike<Result<Employee>>;
-  };
-}
-interface ApplicationToEmployeeOptions extends BuiltInFlowOptions {
-  /** Overrides what the employee takes from the candidate and the job. */
-  readonly map?: (context: FlowContext<ApplicationToEmployeeClients, ApplicationEventData>) => Partial<EmployeeInput>;
-}
-/**
- * An employee in preboarding for each hired application, through
- * `employees.fromApplication`, which records the `created_from` link itself.
- */
-export declare function applicationToEmployee(options?: ApplicationToEmployeeOptions): Flow<ApplicationToEmployeeClients, ApplicationEventData, undefined, Partial<EmployeeInput>>;
-/** `blocks.engagements`, for `bookingToEngagement`. */
-interface BookingToEngagementClients extends FlowClients {
-  readonly engagements: {
-    log(organizationId: string, input: EngagementInput & {
-      readonly type: string;
-      readonly title: string;
-    }, subjects: readonly EngagementSubject[]): PromiseLike<Result<Engagement>>;
-  };
-}
-/** The engagement `bookingToEngagement` logs. */
-type BookingEngagementInput = EngagementInput & {
-  readonly type: string;
-  readonly title: string;
-};
-interface BookingToEngagementOptions extends BuiltInFlowOptions {
-  /**
-   * The engagement for a booking. Default: a `meeting` titled after the
-   * booking.
-   */
-  readonly map?: (context: FlowContext<BookingToEngagementClients, SchedulingEventData>) => BookingEngagementInput;
-  /**
-   * The records the engagement is on besides the booking, such as the customer
-   * who booked.
-   */
-  readonly subjects?: (context: FlowContext<BookingToEngagementClients, SchedulingEventData>) => readonly EngagementSubject[];
-}
-/**
- * A meeting engagement for each confirmed booking, on the booking. It logs with
- * `externalRef: booking:<id>`, so a second log updates the same engagement.
- */
-export declare function bookingToEngagement(options?: BookingToEngagementOptions): Flow<BookingToEngagementClients, SchedulingEventData, undefined, BookingEngagementInput>;
-interface QuoteToOrderOptions extends BuiltInFlowOptions {
-  /**
-   * Creates the order for an accepted quote and returns its id, such as a cart
-   * of the quote's variants and `orders.checkout`. The orders block has no
-   * conversion from a quote, so the app supplies it.
-   */
-  readonly create: (context: FlowContext<FlowClients, QuoteEventData>) => Created;
-}
-/**
- * An order for each accepted quote, linked `created_from` the quote, so the
- * quote's lineage shows the order and an accepted quote orders once.
- */
-export declare function quoteToOrder(options: QuoteToOrderOptions): Flow<FlowClients, QuoteEventData, undefined, undefined>;
-//#endregion
-export type { AnyFlow, ApplicationToEmployeeClients, ApplicationToEmployeeOptions, BookingEngagementInput, BookingToEngagementClients, BookingToEngagementOptions, BuiltInFlowOptions, ConversationToWorkItemClients, ConversationToWorkItemOptions, Flow, FlowClients, FlowContext, FlowEvent, FlowJob, FlowOutcome, FlowRef, FlowRelations, FlowSpec, Flows, FlowsOptions, QuoteToOrderOptions };

package/dist/flows/index.js

@@ -1,229 +0,0 @@
-import { n as dbError } from "../errors-03ysrOt4.js";
-import { a as ok, r as err, t as AsyncResult } from "../result-B3m7xtRY.js";
-import { n as isRecord } from "../guards-6F2bCtQR.js";
-import { n as workItemInputSchema } from "../schemas-ypoQZ_6N.js";
-//#region src/flows/flow.ts
-/**
-* Declares a flow: when an event of type `on` arrives, read the source record,
-* map it to the target block's input and create the target record, once. The
-* new record is linked `created_from` the source, so `relations.lineage` finds
-* the chain and a second run returns the first record.
-*/
-function defineFlow(spec) {
-	return {
-		...spec,
-		apiVersion: 1
-	};
-}
-function flowError(message, hint) {
-	return dbError("invalid_request", message, { hint });
-}
-/** The event's organization: the outbox tenant, or `organizationId` in it. */
-function tenantOf(event) {
-	if (typeof event.tenant === "string" && event.tenant !== "") return event.tenant;
-	const payload = event.payload;
-	const organizationId = isRecord(payload) ? payload["organizationId"] : void 0;
-	return typeof organizationId === "string" && organizationId !== "" ? organizationId : void 0;
-}
-/** The fields of an event a job can store. */
-function jobEvent(event) {
-	return {
-		id: event.id,
-		type: event.type,
-		payload: event.payload,
-		subject: event.subject ?? null,
-		tenant: event.tenant ?? null,
-		actorId: event.actorId ?? null
-	};
-}
-async function validated(schema, value) {
-	if (schema === void 0) return ok(value);
-	const checked = await schema["~standard"].validate(value);
-	if (checked.issues !== void 0) return err(dbError("validation", "The flow's mapped input doesn't pass the target schema", { issues: checked.issues.map((issue) => ({
-		message: issue.message,
-		...issue.path === void 0 ? {} : { path: issue.path.map((part) => typeof part === "object" ? part.key : part) }
-	})) }));
-	return ok(checked.value);
-}
-async function runFlow(flow, event, options) {
-	const source = flow.source(event);
-	if (source === void 0) return ok({ status: "skipped" });
-	const tenant = tenantOf(event);
-	if (tenant === void 0) return err(flowError(`Event ${event.id} names no organization for flow ${flow.name}`, "FLOW_TENANT_REQUIRED"));
-	const clients = await options.clients(tenant, event);
-	const existing = await clients.relations.convertedInto(source, flow.target);
-	if (!existing.ok) return existing;
-	if (existing.data !== void 0) return ok({
-		status: "exists",
-		target: {
-			type: flow.target,
-			id: existing.data
-		}
-	});
-	const context = {
-		clients,
-		tenant,
-		event,
-		source
-	};
-	const loaded = flow.load === void 0 ? ok(void 0) : await flow.load(context);
-	if (!loaded.ok) return loaded;
-	const { map } = flow;
-	const input = await validated(flow.input, map(loaded.data, context));
-	if (!input.ok) return input;
-	const created = await flow.create(input.data, context);
-	if (!created.ok) return created;
-	const target = {
-		type: flow.target,
-		id: created.data.id
-	};
-	if (flow.linksItself !== true) {
-		const linked = await clients.relations.link(target, source, { kind: "created_from" });
-		if (!linked.ok) return linked;
-	}
-	return ok({
-		status: "created",
-		target
-	});
-}
-/**
-* Turns flows on: an outbox consumer that runs, or queues, every flow whose
-* `on` matches an event, and the job handler that runs the queued ones.
-*
-* ```ts
-* const flows = createFlows({
-*   flows: [conversationToWorkItem()],
-*   clients: (tenant) => blocksFor(tenant),
-* });
-* await outbox.consume("flows", flows.sink());
-* ```
-*/
-function createFlows(options) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const flow of options.flows) {
-		if (byName.has(flow.name)) throw new TypeError(`Two flows are named ${flow.name}`);
-		byName.set(flow.name, flow);
-	}
-	const matching = (type) => options.flows.filter((flow) => typeof flow.on === "string" ? flow.on === type : flow.on.includes(type)).map((flow) => flow.name);
-	const run = (name, event) => AsyncResult.from(async () => {
-		const flow = byName.get(name);
-		if (flow === void 0) return err(flowError(`No flow is named ${name}`, "FLOW_NOT_FOUND"));
-		const outcome = await runFlow(flow, event, options);
-		if (outcome.ok) options.onOutcome?.(name, event, outcome.data);
-		return outcome;
-	});
-	return {
-		matching,
-		run,
-		sink: () => async (events) => {
-			for (const event of events) for (const name of matching(event.type)) {
-				if (options.enqueue === void 0) {
-					await run(name, event).orThrow();
-					continue;
-				}
-				const queued = await options.enqueue({
-					flow: name,
-					event: jobEvent(event)
-				}, `flow:${name}:${event.id}`);
-				if (!queued.ok) await AsyncResult.err(queued.error).orThrow();
-			}
-		},
-		handler: () => async (payload) => {
-			await run(payload.flow, payload.event).orThrow();
-		}
-	};
-}
-//#endregion
-//#region src/flows/built-ins.ts
-function conversationTitle(conversation) {
-	const title = conversation.subject ?? conversation.preview ?? "";
-	return title.trim() === "" ? `Conversation ${conversation.id}` : title.slice(0, 500);
-}
-/**
-* A work item for each conversation the inbox opens, linked `created_from` the
-* conversation. The mapped input passes the work item input schema.
-*/
-function conversationToWorkItem(options = {}) {
-	return defineFlow({
-		name: "conversationToWorkItem",
-		on: options.on ?? "inbox_conversation.opened",
-		target: options.targetType ?? "work_item",
-		source: (event) => ({
-			type: options.sourceType ?? "inbox_conversation",
-			id: event.payload.conversationId
-		}),
-		load: async ({ clients, source }) => {
-			const found = await clients.inbox.conversations.get(source.id);
-			if (!found.ok) return found;
-			return found.data === null ? err(dbError("not_found", `No conversation ${source.id}`)) : ok(found.data);
-		},
-		input: workItemInputSchema,
-		map: (conversation, context) => options.map?.(conversation, context) ?? {
-			title: conversationTitle(conversation),
-			...conversation.preview === null ? {} : { body: conversation.preview }
-		},
-		create: (input, { clients, tenant, event }) => thenId(clients.workItems.create(tenant, input, options.assign !== false && typeof event.payload.assigneeId === "string" ? [event.payload.assigneeId] : void 0))
-	});
-}
-/**
-* An employee in preboarding for each hired application, through
-* `employees.fromApplication`, which records the `created_from` link itself.
-*/
-function applicationToEmployee(options = {}) {
-	return defineFlow({
-		name: "applicationToEmployee",
-		on: options.on ?? "application.hired",
-		target: options.targetType ?? "employee",
-		source: (event) => ({
-			type: options.sourceType ?? "application",
-			id: event.payload.applicationId
-		}),
-		map: (_, context) => options.map?.(context) ?? {},
-		create: (overrides, { clients, source }) => thenId(clients.employees.fromApplication(source.id, overrides)),
-		linksItself: true
-	});
-}
-/**
-* A meeting engagement for each confirmed booking, on the booking. It logs with
-* `externalRef: booking:<id>`, so a second log updates the same engagement.
-*/
-function bookingToEngagement(options = {}) {
-	return defineFlow({
-		name: "bookingToEngagement",
-		on: options.on ?? "booking.confirmed",
-		target: options.targetType ?? "engagement",
-		source: (event) => typeof event.payload.id === "string" ? {
-			type: options.sourceType ?? "booking",
-			id: event.payload.id
-		} : void 0,
-		map: (_, context) => options.map?.(context) ?? {
-			type: "meeting",
-			title: context.event.payload.name ?? "Booking",
-			externalRef: `booking:${context.source.id}`
-		},
-		create: (input, context) => thenId(context.clients.engagements.log(context.tenant, input, [context.source, ...options.subjects?.(context) ?? []]))
-	});
-}
-/**
-* An order for each accepted quote, linked `created_from` the quote, so the
-* quote's lineage shows the order and an accepted quote orders once.
-*/
-function quoteToOrder(options) {
-	return defineFlow({
-		name: "quoteToOrder",
-		on: options.on ?? "quote.accepted",
-		target: options.targetType ?? "order",
-		source: (event) => ({
-			type: options.sourceType ?? "quote",
-			id: event.payload.quoteId
-		}),
-		map: () => void 0,
-		create: (_, context) => options.create(context)
-	});
-}
-async function thenId(created) {
-	const result = await created;
-	return result.ok ? ok({ id: result.data.id }) : result;
-}
-//#endregion
-export { applicationToEmployee, bookingToEngagement, conversationToWorkItem, createFlows, defineFlow, quoteToOrder };

package/dist/format-AYHceC2m.d.ts

@@ -1,79 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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-vPqwt1j4.d.ts

@@ -1,27 +0,0 @@
-import { t as StandardSchemaV1 } from "./standard-DbQsD2xZ.js";
-//#region src/core/function-contract.d.ts
-/** What a typed Edge Function takes and returns, as the caller sees them. */
-interface FunctionContract<In = unknown, Out = unknown> {
-  readonly input: In;
-  readonly output: Out;
-}
-/**
- * The key `defineFunction` stores its schemas under, so `better-supabase/spec`
- * can read them without importing `edge`.
- */
-declare const FUNCTION_DESCRIPTOR: unique symbol;
-/**
- * The schemas and docs of a `defineFunction` handler, kept on the handler for
- * spec generation.
- */
-interface FunctionDescriptor {
-  readonly input: StandardSchemaV1;
-  readonly output?: StandardSchemaV1;
-  readonly summary?: string;
-}
-/** A handler that carries a `FunctionDescriptor`. */
-interface DescribedFunction {
-  readonly [FUNCTION_DESCRIPTOR]: FunctionDescriptor;
-}
-//#endregion
-export { FunctionContract as n, DescribedFunction as t };