better-supabase 0.0.0 → 0.2.0

package/dist/resource-BHEWmQJK.js

@@ -0,0 +1,175 @@
+import { n as dbError } from "./errors-Bl3rkOzo.js";
+import { i as ok, n as err } from "./result-DWXatkd6.js";
+import { t as validate } from "./standard-FUi3Z3-7.js";
+import { i as respond } from "./respond-DMcbQwfN.js";
+//#region src/server/resource.ts
+const INTEGER = /* @__PURE__ */ new Set([
+	"int2",
+	"int4",
+	"int8"
+]);
+function keyValue(table, raw) {
+	const invalid = err(dbError("invalid_request", `${JSON.stringify(raw)} is not a valid ${table.key} key`));
+	const column = table.columns[table.primaryKey[0]];
+	if (column && INTEGER.has(column.type)) {
+		const value = typeof raw === "string" ? Number(raw) : raw;
+		return typeof value === "number" && Number.isSafeInteger(value) ? ok(value) : invalid;
+	}
+	return typeof raw === "string" && raw !== "" ? ok(raw) : invalid;
+}
+async function readBody(request) {
+	try {
+		const body = await request.json();
+		if (typeof body === "object" && body !== null && !Array.isArray(body)) return ok(body);
+	} catch {}
+	return err(dbError("invalid_request", "The request body must be a JSON object"));
+}
+function pageArgs(query, max) {
+	const read = (name, fallback) => {
+		const raw = query instanceof URLSearchParams ? query.get(name) : query?.[name];
+		if (raw === null || raw === void 0 || raw === "") return fallback;
+		const value = Number(raw);
+		return Number.isSafeInteger(value) && value >= 1 ? value : void 0;
+	};
+	const page = read("page", 1);
+	const size = read("size", 50);
+	if (page === void 0 || size === void 0 || size > max) return err(dbError("validation", "Invalid page parameters", { issues: [...page === void 0 ? [{
+		message: "Must be a positive integer",
+		path: ["page"]
+	}] : [], ...size === void 0 || size > max ? [{
+		message: `Must be between 1 and ${max}`,
+		path: ["size"]
+	}] : []] }));
+	return ok({
+		page,
+		size
+	});
+}
+function asObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? ok(value) : err(dbError("invalid_request", "Expected an object of column values"));
+}
+async function settled(value) {
+	return await value;
+}
+function notAllowed(allowed) {
+	return new Response(null, {
+		status: 405,
+		headers: { allow: allowed.join(", ") }
+	});
+}
+/**
+* Operations over one table, matching the paths and responses of
+* `createOpenApi`: `GET/POST /<table>` and `GET/PATCH/DELETE /<table>/{id}`.
+* Shared by the HTTP adapters and the MCP table tools.
+*/
+function defineResource(sb, table, options = {}) {
+	const meta = sb.meta.tables[table];
+	if (!meta) throw new TypeError(`Unknown table "${table}"`);
+	if (options.list && options.list.table !== table) throw new TypeError(`The list query is for "${options.list.table}", not "${table}"`);
+	const operations = options.operations ?? (meta.kind === "view" ? ["list", "get"] : [
+		"list",
+		"get",
+		"create",
+		"update",
+		"delete"
+	]);
+	const keyParam = meta.primaryKey.length === 1 ? meta.primaryKey[0] : void 0;
+	const has = (operation) => operations.includes(operation);
+	const extra = options.select === void 0 ? {} : { select: options.select };
+	const maxPageSize = options.maxPageSize ?? 200;
+	const list = options.list;
+	const execute = async (db, operation, input = {}) => {
+		const repository = db[table];
+		if (!repository) throw new TypeError(`The db has no "${table}" repository`);
+		if (!has(operation)) return err(dbError("forbidden", `${operation} is not enabled for ${table}`));
+		const key = () => keyParam ? keyValue(meta, input.id) : err(dbError("invalid_request", `${table} has no single-column key`));
+		switch (operation) {
+			case "list": {
+				if (list) {
+					const query = list.parse(input.query ?? {});
+					if (!query.ok) return err(dbError("validation", "Invalid list query", { issues: query.issues }));
+					return settled(list.run(db, query.value, extra));
+				}
+				const page = pageArgs(input.query, maxPageSize);
+				if (!page.ok) return page;
+				return settled(repository.paginate({
+					...extra,
+					...page.data,
+					count: "exact"
+				}));
+			}
+			case "get": {
+				const id = key();
+				if (!id.ok) return id;
+				return settled(repository.findById(id.data, extra));
+			}
+			case "create": {
+				const body = asObject(input.data);
+				if (!body.ok) return body;
+				const data = options.input?.create ? await validate(options.input.create, body.data, "data") : body;
+				if (!data.ok) return data;
+				return settled(repository.create(data.data, extra));
+			}
+			case "update": {
+				const id = key();
+				if (!id.ok) return id;
+				const body = asObject(input.data);
+				if (!body.ok) return body;
+				const data = options.input?.update ? await validate(options.input.update, body.data, "data") : body;
+				if (!data.ok) return data;
+				return settled(repository.update(id.data, data.data, extra));
+			}
+			case "delete": {
+				const id = key();
+				if (!id.ok) return id;
+				return settled(repository.delete(id.data));
+			}
+			default: throw new TypeError(`Unknown operation ${String(operation)}`);
+		}
+	};
+	const collectionMethods = [...has("list") ? ["GET"] : [], ...has("create") ? ["POST"] : []];
+	const itemMethods = [
+		...has("get") ? ["GET"] : [],
+		...has("update") ? ["PATCH"] : [],
+		...has("delete") ? ["DELETE"] : []
+	];
+	const route = async (request, db, id) => {
+		if (id === void 0) {
+			if (request.method === "GET" && has("list")) return execute(db, "list", { query: new URL(request.url).searchParams });
+			if (request.method === "POST" && has("create")) {
+				const body = await readBody(request);
+				return body.ok ? execute(db, "create", { data: body.data }) : body;
+			}
+			return notAllowed(collectionMethods);
+		}
+		if (!keyParam) return new Response(null, { status: 404 });
+		if (request.method === "GET" && has("get")) return execute(db, "get", { id });
+		if (request.method === "PATCH" && has("update")) {
+			const body = await readBody(request);
+			return body.ok ? execute(db, "update", {
+				id,
+				data: body.data
+			}) : body;
+		}
+		if (request.method === "DELETE" && has("delete")) return execute(db, "delete", { id });
+		return notAllowed(itemMethods);
+	};
+	return {
+		table,
+		meta,
+		operations,
+		keyParam,
+		list,
+		maxPageSize,
+		execute,
+		handle(request, db, id, respondOptions = {}) {
+			const status = id === void 0 && request.method === "POST" ? 201 : void 0;
+			return respond(() => route(request, db, id), status === void 0 ? respondOptions : {
+				...respondOptions,
+				status
+			});
+		}
+	};
+}
+//#endregion
+export { defineResource as t };

package/dist/resource-CgZa3YG_.d.ts

@@ -0,0 +1,65 @@
+import { N as TableKey, P as TableMeta, R as Update, _ as Insert, n as AnyModels, t as AnyFunctions } from "./types-C83v5SQz.js";
+import { b as ValidationIssue, o as Result } from "./result-CTkCZ6JA.js";
+import { t as BetterSupabase, xt as SelectArg } from "./define-e3zI4_4g.js";
+import { r as RespondOptions } from "./respond-Dne1ARSa.js";
+import { i as ResourceOperation } from "./index-DbxFr7XG.js";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/server/resource.d.ts
+/** What a resource needs from `defineListQuery`. */
+interface ResourceList {
+  readonly table: string;
+  readonly openapi: readonly unknown[];
+  readonly jsonSchema: Readonly<Record<string, unknown>>;
+  parse(input: never): {
+    readonly ok: true;
+    readonly value: unknown;
+  } | {
+    readonly ok: false;
+    readonly issues: readonly ValidationIssue[];
+  };
+  run(db: never, query: never, extra?: never): PromiseLike<unknown>;
+}
+interface ResourceRouteOptions<M extends AnyModels, T extends TableKey<M>> {
+  /** Defaults to every operation for tables, `list` and `get` for views. */
+  readonly operations?: readonly ResourceOperation[];
+  /** Filters, search and sorts for `list`, from `defineListQuery`. */
+  readonly list?: ResourceList;
+  /** Columns returned by every operation. */
+  readonly select?: SelectArg<M, T>;
+  /** Validates request bodies before they reach the repository. */
+  readonly input?: {
+    readonly create?: StandardSchemaV1<unknown, Insert<M, T>>;
+    readonly update?: StandardSchemaV1<unknown, Update<M, T>>;
+  };
+  /** Largest page for the default `page`/`size` list. Defaults to 200. */
+  readonly maxPageSize?: number;
+}
+interface ResourceInput {
+  /** Primary key value; strings are converted for integer keys. */
+  readonly id?: unknown;
+  /** Body of `create` and `update`. */
+  readonly data?: unknown;
+  /** `list` parameters: URL params or typed values. */
+  readonly query?: URLSearchParams | Readonly<Record<string, unknown>>;
+}
+interface ResourceHandler {
+  readonly table: string;
+  readonly meta: TableMeta;
+  readonly operations: readonly ResourceOperation[];
+  /** Name of the key parameter, or `undefined` for tables without a single-column key. */
+  readonly keyParam: string | undefined;
+  readonly list: ResourceList | undefined;
+  readonly maxPageSize: number;
+  /** Runs one operation as whoever `db` is bound to. Resolves to a `Result`. */
+  execute(db: object, operation: ResourceOperation, input?: ResourceInput): Promise<Result<unknown>>;
+  /** Serves a collection request (`id` undefined) or an item request. */
+  handle(request: Request, db: object, id: string | undefined, options?: RespondOptions): Promise<Response>;
+}
+/**
+ * Operations over one table, matching the paths and responses of
+ * `createOpenApi`: `GET/POST /<table>` and `GET/PATCH/DELETE /<table>/{id}`.
+ * Shared by the HTTP adapters and the MCP table tools.
+ */
+declare function defineResource<M extends AnyModels, D, F extends AnyFunctions, E, T extends TableKey<M>>(sb: BetterSupabase<M, D, F, E>, table: T, options?: ResourceRouteOptions<M, T>): ResourceHandler;
+//#endregion
+export { defineResource as a, ResourceRouteOptions as i, ResourceInput as n, ResourceList as r, ResourceHandler as t };

package/dist/respond-DMcbQwfN.js

@@ -0,0 +1,383 @@
+import { n as dbError, o as isDbError, r as dbErrorOf } from "./errors-Bl3rkOzo.js";
+import { i as ok, n as err, o as toDbError, t as AsyncResult } from "./result-DWXatkd6.js";
+import { a as postgrestExecutor, n as StatsRecorder } from "./stats-C5W-rBfR.js";
+import { a as problemResponse } from "./problem-BTkTtRV9.js";
+import { i as loadEnv } from "./env-BEToab0I.js";
+import { h as actClaim, i as authContext, o as resolveAuth, r as checkAal } from "./mfa-CpLfJSde.js";
+import { n as postgresExecutor } from "./executor-DeppvirK.js";
+import { createClient } from "@supabase/supabase-js";
+//#region src/server/replicas.ts
+/** Cookie holding the epoch ms until which reads stay on the primary. */
+const PRIMARY_COOKIE = "bs-primary-until";
+/** Default time reads stay on the primary after a write. */
+const DEFAULT_PIN_MS = 5e3;
+function replicaState(pinnedUntil = 0, now = Date.now()) {
+	let wrote = false;
+	const inherited = pinnedUntil > now;
+	return {
+		get pinned() {
+			return wrote || inherited;
+		},
+		get wrote() {
+			return wrote;
+		},
+		pin() {
+			wrote = true;
+		}
+	};
+}
+/** `bs-primary-until` from a `cookie` header, or 0. */
+function pinnedUntil(cookieHeader) {
+	if (!cookieHeader) return 0;
+	for (const part of cookieHeader.split(";")) {
+		const [name, value] = part.trim().split("=", 2);
+		if (name === "bs-primary-until") {
+			const until = Number(value);
+			return Number.isFinite(until) ? until : 0;
+		}
+	}
+	return 0;
+}
+/** A `Set-Cookie` value keeping the next requests on the primary for `pinMs`. */
+function primaryCookie(pinMs, now = Date.now()) {
+	const seconds = Math.max(1, Math.ceil(pinMs / 1e3));
+	return `${PRIMARY_COOKIE}=${String(now + pinMs)}; Path=/; Max-Age=${String(seconds)}; HttpOnly; SameSite=Lax`;
+}
+/**
+* Reads go to `replica` until the context is pinned; writes, and every read
+* after a successful write, go to `primary`.
+*/
+function routedExecutor(primary, replica, state) {
+	const batch = primary.batch?.bind(primary);
+	const replicaBatch = replica.batch?.bind(replica);
+	return {
+		name: primary.name,
+		...primary.functionSources && replica.functionSources ? { functionSources: true } : {},
+		async execute(op, context) {
+			if (op.kind === "select" && !state.pinned) return replica.execute(op, context);
+			const result = await primary.execute(op, context);
+			if (op.kind !== "select" && result.ok) state.pin();
+			return result;
+		},
+		...primary.rpc ? { async rpc(name, args, context) {
+			if (context.get && !state.pinned && replica.rpc) return replica.rpc(name, args, context);
+			const result = await primary.rpc(name, args, context);
+			if (!context.get && result.ok) state.pin();
+			return result;
+		} } : {},
+		...batch ? { batch: (ops, context) => !state.pinned && replicaBatch ? replicaBatch(ops, context) : batch(ops, context) } : {}
+	};
+}
+//#endregion
+//#region src/server/delete-account.ts
+const REMOVE_BATCH = 1e3;
+/** Maps an `AuthApiError` from `auth.admin.deleteUser` to a `DbError`. */
+function fromAuthError(raw) {
+	if (isDbError(raw)) return raw;
+	const failure = typeof raw === "object" && raw !== null ? raw : {};
+	const message = failure.message ?? "Auth request failed";
+	const base = {
+		table: "auth.users",
+		...failure.code ? { code: failure.code } : {}
+	};
+	if (failure.code === "user_not_found" || failure.status === 404) return dbError("not_found", message, base);
+	if (/database error deleting user/i.test(message)) return dbError("conflict", message, {
+		...base,
+		hint: "A foreign key to auth.users without on delete cascade or set null blocks the delete (doctor BS406)"
+	});
+	if (failure.status === 401) return dbError("unauthorized", message, base);
+	if (failure.status === 403) return dbError("forbidden", message, base);
+	return failure.name === "AuthRetryableFetchError" || (failure.status ?? 0) >= 500 ? dbError("network", message, base) : dbError("unexpected", message, base);
+}
+/**
+* Removes a user's Storage objects, then the Auth user, then announces the
+* delete. Rows referencing `auth.users` follow their foreign keys.
+*/
+function deleteAccount(sb, service, userId, options = {}) {
+	return AsyncResult.from(async () => {
+		const client = service();
+		const removed = {};
+		for (const bucket of options.buckets ?? []) {
+			const param = bucket.owner;
+			if (!param) continue;
+			options.signal?.throwIfAborted();
+			const storage = bucket.connect(client);
+			const listed = await storage.list({ [param]: userId }, options.signal ? { signal: options.signal } : {});
+			if (!listed.ok) return listed;
+			const paths = listed.data.map((object) => object.path).filter((path) => {
+				return bucket.match(path)?.[param] === userId;
+			});
+			for (let start = 0; start < paths.length; start += REMOVE_BATCH) {
+				const batch = await storage.remove(paths.slice(start, start + REMOVE_BATCH));
+				if (!batch.ok) return batch;
+			}
+			removed[bucket.id] = paths.length;
+		}
+		options.signal?.throwIfAborted();
+		try {
+			const { error } = await client.auth.admin.deleteUser(userId);
+			if (error) return err(fromAuthError(error));
+		} catch (cause) {
+			return err(fromAuthError(cause));
+		}
+		const context = options.context ?? {};
+		sb.events.emit("mutation", {
+			table: "auth.users",
+			kind: "delete",
+			rows: [{ id: userId }],
+			context
+		});
+		for (const table of options.cascades ?? []) sb.events.emit("mutation", {
+			table,
+			kind: "delete",
+			rows: [],
+			context
+		});
+		return ok({
+			userId,
+			removed
+		});
+	});
+}
+//#endregion
+//#region src/server/server.ts
+const STATELESS = {
+	persistSession: false,
+	autoRefreshToken: false,
+	detectSessionInUrl: false
+};
+/** `{ ...server, ...extra }` without reading the lazy `env` getter. */
+function extendServer(server, extra) {
+	return Object.defineProperties({}, {
+		...Object.getOwnPropertyDescriptors(server),
+		...Object.getOwnPropertyDescriptors(extra)
+	});
+}
+/** `{ ...base, ...extra }` that keeps lazy getters lazy. */
+function withExtra(base, extra) {
+	return Object.defineProperties({}, {
+		...Object.getOwnPropertyDescriptors(base),
+		...Object.getOwnPropertyDescriptors(extra)
+	});
+}
+/**
+* Server-side entry point for APIs, jobs, MCP servers and framework
+* adapters. Holds the secrets; `sb` stays isomorphic.
+*/
+function createServer(sb, options = {}) {
+	let loaded;
+	const env = () => loaded ??= options.env ?? loadEnv();
+	let adminClient;
+	let anonClient;
+	const secretKey = () => {
+		const key = env().secretKey;
+		if (!key) throw new TypeError("admin() needs SUPABASE_SECRET_KEY; it is not set");
+		return key;
+	};
+	const serviceClient = () => {
+		adminClient ??= createClient(env().url, secretKey(), { auth: STATELESS });
+		return adminClient;
+	};
+	const readUrl = () => options.readUrl === false ? void 0 : options.readUrl?.replace(/\/+$/, "") ?? env().readUrl;
+	/** Clients for the primary share the service and anon clients; others don't. */
+	const supabaseAt = (url, auth, headers = {}) => {
+		const global = Object.keys(headers).length > 0 ? { global: { headers } } : void 0;
+		const shared = !global && url === env().url;
+		switch (auth.kind) {
+			case "user": return createClient(url, env().publishableKey, {
+				accessToken: () => Promise.resolve(auth.token),
+				...global
+			});
+			case "service": return shared ? serviceClient() : createClient(url, secretKey(), {
+				auth: STATELESS,
+				...global
+			});
+			case "anon":
+			case "invalid":
+				if (!shared) return createClient(url, env().publishableKey, {
+					auth: STATELESS,
+					...global
+				});
+				anonClient ??= createClient(url, env().publishableKey, { auth: STATELESS });
+				return anonClient;
+			default: return auth;
+		}
+	};
+	const supabaseFor = (auth, headers = {}) => supabaseAt(env().url, auth, headers);
+	const dbFor = (auth, context = {}) => sb.connect(supabaseFor(auth), {
+		...authContext(auth),
+		...context
+	});
+	const sqlFor = (claims, context, stats) => {
+		if (!options.postgres) throw new TypeError("Direct Postgres access needs createServer(sb, { postgres: createPostgres() })");
+		return sb.connect(postgresExecutor(options.postgres.asUser(claims)), context, stats ? { stats } : {});
+	};
+	/** Clients and repositories are built on first access: most scopes use one of them. */
+	const contextFor = (resolution, headers, parent, until = 0) => {
+		const { auth } = resolution;
+		const context = authContext(auth);
+		const recorder = new StatsRecorder(parent);
+		let supabase;
+		let db;
+		let sql;
+		const sqlClaims = auth.kind === "user" ? auth.claims : auth.kind === "anon" ? { role: "anon" } : void 0;
+		const client = () => supabase ??= supabaseFor(auth, headers);
+		let replica;
+		const replicaUrl = () => {
+			const url = readUrl();
+			if (url) replica ??= replicaState(until);
+			return url;
+		};
+		return {
+			auth,
+			resolution,
+			get supabase() {
+				return client();
+			},
+			get db() {
+				if (db) return db;
+				const url = replicaUrl();
+				db = sb.connect(client(), context, {
+					stats: recorder,
+					...url && replica ? { executor: routedExecutor(postgrestExecutor(client()), postgrestExecutor(supabaseAt(url, auth, headers)), replica) } : {}
+				});
+				return db;
+			},
+			get replica() {
+				replicaUrl();
+				return replica;
+			},
+			get sql() {
+				if (!options.postgres || !sqlClaims) return void 0;
+				sql ??= sqlFor(sqlClaims, context, recorder);
+				return sql;
+			},
+			stats: () => recorder.snapshot()
+		};
+	};
+	const resolve = async (request, resolveOptions = {}) => {
+		const claims = options.auth?.claims ?? sb.claimsSchema;
+		const userMetadata = sb.userMetadataSchema;
+		const resolution = await resolveAuth(request, {
+			logger: sb.events.logger,
+			...options.auth,
+			...claims ? { claims } : {},
+			...userMetadata ? { userMetadata } : {},
+			env: env(),
+			...resolveOptions.refresh !== void 0 ? { refresh: resolveOptions.refresh } : {},
+			onRefresh: (event) => {
+				options.auth?.onRefresh?.(event);
+				sb.events.emit("refresh", event);
+			}
+		});
+		if (sb.events.has("auth")) {
+			const { auth } = resolution;
+			sb.events.emit("auth", {
+				source: auth.kind === "user" ? auth.source === "cookie" ? "cookie" : "bearer" : auth.kind === "service" ? "bearer" : "none",
+				ok: auth.kind !== "invalid",
+				...auth.kind === "user" ? { userId: auth.user.id } : {}
+			});
+		}
+		return resolution;
+	};
+	return {
+		get env() {
+			return env();
+		},
+		resolve,
+		supabaseFor,
+		dbFor,
+		contextFor: (auth, contextOptions = {}) => contextFor({
+			auth,
+			cookies: [],
+			headers: {},
+			requestCookies: [],
+			apply: (response) => response
+		}, {}, contextOptions.stats, contextOptions.pinnedUntil),
+		async context(request, contextOptions = {}) {
+			const resolution = await resolve(request, { refresh: contextOptions.refresh ?? false });
+			return contextFor(resolution, options.headers?.(request) ?? {}, contextOptions.stats, contextOptions.pinnedUntil ?? pinnedUntil(request.headers.get("cookie")));
+		},
+		admin: (context = {}) => sb.connect(serviceClient(), {
+			actor: {
+				id: "service",
+				kind: "service",
+				role: "service_role"
+			},
+			claims: { role: "service_role" },
+			...context
+		}),
+		deleteAccount: (userId, deleteOptions) => deleteAccount(sb, serviceClient, userId, deleteOptions),
+		actingAs: (userId, claims = {}, impersonation) => {
+			const full = {
+				role: "authenticated",
+				...claims,
+				sub: userId,
+				...impersonation ? { act: actClaim(impersonation) } : {}
+			};
+			return sqlFor(full, {
+				actor: {
+					id: userId,
+					kind: "user",
+					role: full.role ?? "authenticated",
+					...impersonation ? { impersonator: impersonation.actor } : {}
+				},
+				claims: full
+			});
+		}
+	};
+}
+//#endregion
+//#region src/server/respond.ts
+/** `undefined` when `auth` may pass; otherwise the 401/403 error to send. */
+function guard(auth, allow = ["user"], aal = "aal1") {
+	if (auth.kind === "invalid") return auth.error;
+	if (allow.includes(auth.kind)) return checkAal(auth, aal);
+	return auth.kind === "anon" ? dbError("unauthorized", "Sign in to continue", { code: "MISSING_CREDENTIALS" }) : dbError("forbidden", `A ${auth.kind} caller is not allowed here`);
+}
+function isResult(value) {
+	return typeof value === "object" && value !== null && "ok" in value && "data" in value && "error" in value;
+}
+/**
+* Settles a handler's return value: `Result`s and `AsyncResult`s unwrap,
+* thrown `DbException`s (or errors whose `cause` is a `DbError`) become
+* errors, anything else is data. Other thrown
+* errors propagate.
+*/
+async function settle(run) {
+	try {
+		const value = await run();
+		if (!isResult(value)) return {
+			ok: true,
+			data: value
+		};
+		if (value.ok) return {
+			ok: true,
+			data: value.data
+		};
+		return {
+			ok: false,
+			error: isDbError(value.error) ? value.error : toDbError(value.error)
+		};
+	} catch (cause) {
+		const thrown = dbErrorOf(cause);
+		if (thrown) return {
+			ok: false,
+			error: thrown
+		};
+		throw cause;
+	}
+}
+/** A handler's value as a response: `Response` as is, data as JSON, errors as Problem Details. */
+async function respond(run, options = {}) {
+	const settled = await settle(run);
+	if (!settled.ok) return problemResponse(settled.error, options);
+	if (settled.data instanceof Response) return settled.data;
+	if (settled.data === void 0) return new Response(null, { status: 204 });
+	return Response.json(settled.data, { status: options.status ?? 200 });
+}
+function defaultExpose() {
+	return typeof process !== "undefined" && process.env["NODE_ENV"] === "development";
+}
+//#endregion
+export { settle as a, withExtra as c, primaryCookie as d, respond as i, DEFAULT_PIN_MS as l, guard as n, createServer as o, isResult as r, extendServer as s, defaultExpose as t, PRIMARY_COOKIE as u };