better-supabase 0.1.0 → 0.3.0

package/dist/mcp/index.js

@@ -1,15 +1,32 @@
 import { n as dbError } from "../errors-Bl3rkOzo.js";
+import { t as base64ToText } from "../base64-CQeB1eSf.js";
 import { t as validate } from "../standard-FUi3Z3-7.js";
-import { o as toProblem } from "../problem-DPu6Fh-t.js";
-import { t as SPEC_PINS } from "../spec-pins-t6sPaHvl.js";
-import { t as buildJsonSchema } from "../json-schema-BbwO2mZg.js";
-import { a as settle, c as withExtra, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-4-dhoV7x.js";
-import { t as defineResource } from "../resource-CYiu6Ygi.js";
-import { fromSupabaseUrl, resourceMetadataResponse, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
-//#region src/mcp/index.ts
+import { o as toProblem } from "../problem-CGt1ADix.js";
+import { t as SPEC_PINS } from "../spec-pins-C3oc-Tdp.js";
+import { t as buildJsonSchema } from "../json-schema--aOXAGfU.js";
+import { a as settle, c as withExtra, n as guard, o as createServer, s as extendServer, t as defaultExpose } from "../respond-C44EZAJo.js";
+import { t as defineResource } from "../resource-D30rp0GN.js";
+import { fromSupabaseUrl, unauthorizedResponse } from "@supabase/server/oauth-protected-resource";
+//#region src/mcp/mcp.ts
 const MCP_PROTOCOL_VERSION = SPEC_PINS.mcp;
 const WELL_KNOWN = "/.well-known/oauth-protected-resource";
-const SUPPORTED_VERSIONS = /* @__PURE__ */ new Set([MCP_PROTOCOL_VERSION, "2025-03-26"]);
+/** Revisions before 2026-07-28 open with an `initialize` handshake. */
+const LEGACY_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26"
+];
+const SUPPORTED_VERSIONS = [MCP_PROTOCOL_VERSION, ...LEGACY_VERSIONS];
+/** The `Host` header's hostname is in the list; a missing or malformed header is not. */
+function hostAllowed(request, allowed) {
+	const host = request.headers.get("host");
+	if (!host) return false;
+	try {
+		return allowed.includes(new URL(`http://${host}`).hostname);
+	} catch {
+		return false;
+	}
+}
 /** A custom tool. Pass it in `createMcp({ tools: [...] })`. */
 function defineTool(definition) {
 	if (!/^[A-Za-z0-9_.-]{1,64}$/.test(definition.name)) throw new TypeError(`Invalid tool name "${definition.name}": use 1-64 letters, digits, "_", "-" or "."`);
@@ -30,6 +47,7 @@ function defineTool(definition) {
 			...definition.annotations ? { annotations: definition.annotations } : {}
 		},
 		...definition.input ? { input: definition.input } : {},
+		...definition.meta === void 0 ? {} : { meta: definition.meta },
 		run: (args, ctx) => definition.run(args, ctx)
 	};
 }
@@ -60,15 +78,15 @@ const ANNOTATIONS = {
 		openWorldHint: false
 	}
 };
-function pageSchema(max) {
+function pageSchema(max, cursor) {
 	return {
 		type: "object",
 		properties: {
-			page: {
+			...cursor ? { after: { type: "string" } } : { page: {
 				type: "integer",
 				minimum: 1,
 				default: 1
-			},
+			} },
 			size: {
 				type: "integer",
 				minimum: 1,
@@ -92,7 +110,23 @@ function tableTools(resource, defs) {
 		required: [keyParam, ...Object.keys(more)],
 		additionalProperties: false
 	});
-	const page = {
+	const cursor = resource.pagination === "cursor";
+	const page = cursor ? {
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: row
+			},
+			nextCursor: { type: ["string", "null"] },
+			hasMore: { type: "boolean" }
+		},
+		required: [
+			"items",
+			"nextCursor",
+			"hasMore"
+		]
+	} : {
 		type: "object",
 		properties: {
 			items: {
@@ -119,7 +153,7 @@ function tableTools(resource, defs) {
 	};
 	for (const operation of resource.operations) switch (operation) {
 		case "list": {
-			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageSchema(resource.maxPageSize);
+			const { $schema: _, ...listSchema } = resource.list?.jsonSchema ?? pageSchema(resource.maxPageSize, cursor);
 			add("list", `List ${table} rows visible to the caller, one page at a time.`, listSchema, page);
 			break;
 		}
@@ -143,18 +177,38 @@ const PARSE_ERROR = -32700;
 const INVALID_REQUEST = -32600;
 const METHOD_NOT_FOUND = -32601;
 const INVALID_PARAMS = -32602;
-function rpcError(id, code, message, status = 200) {
+const HEADER_MISMATCH = -32020;
+const UNSUPPORTED_PROTOCOL_VERSION = -32022;
+const META_VERSION = "io.modelcontextprotocol/protocolVersion";
+const META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
+const META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+/** How long clients may cache `tools/list` and `server/discover` (per token). */
+const LIST_TTL_MS = 3e5;
+function rpcError(id, code, message, status = 200, data) {
 	return Response.json({
 		jsonrpc: "2.0",
 		id: id ?? null,
 		error: {
 			code,
-			message
+			message,
+			...data ? { data } : {}
 		}
 	}, { status });
 }
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** An `Mcp-Name` value, decoding the `=?base64?...?=` sentinel. */
+function headerName(value) {
+	const encoded = /^=\?base64\?(.*)\?=$/.exec(value)?.[1];
+	if (encoded === void 0) return value;
+	try {
+		return base64ToText(encoded);
+	} catch {
+		return value;
+	}
+}
+const quoted = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
 function isRpcRequest(value) {
-	return typeof value === "object" && value !== null && value["jsonrpc"] === "2.0" && typeof value["method"] === "string";
+	return isObject(value) && value["jsonrpc"] === "2.0" && typeof value["method"] === "string" && (value["params"] === void 0 || isObject(value["params"]));
 }
 function textResult(value, isError = false) {
 	const structured = typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
@@ -185,43 +239,75 @@ function createMcp(sb, options) {
 		config: { json: options.json ?? {} }
 	})["$defs"];
 	const registry = /* @__PURE__ */ new Map();
-	const register = (info, call) => {
-		if (registry.has(info.name)) throw new TypeError(`Duplicate MCP tool "${info.name}"`);
-		registry.set(info.name, {
-			info,
-			call
-		});
+	const register = (entry) => {
+		if (registry.has(entry.info.name)) throw new TypeError(`Duplicate MCP tool "${entry.info.name}"`);
+		registry.set(entry.info.name, entry);
 	};
 	const failure = (error) => textResult(toProblem(error, { expose }), true);
+	const refused = async (tool, args, ctx) => {
+		if (!options.authorize) return void 0;
+		const decision = await options.authorize(ctx, tool, args);
+		if (decision.allowed) return void 0;
+		return {
+			refusal: decision.reason ?? `Not allowed to call ${tool.info.name}`,
+			scopes: decision.scopes ?? []
+		};
+	};
+	const isVisible = async (tool, ctx) => !options.visible || options.visible(ctx, tool);
 	for (const [table, raw] of Object.entries(options.resources ?? {})) {
 		if (!raw) continue;
 		const resource = defineResource(sb, table, raw === true ? {} : raw);
-		for (const { info, operation } of tableTools(resource, defs)) register(info, async (args, ctx) => {
-			const input = args ?? {};
-			const id = resource.keyParam ? input[resource.keyParam] : void 0;
-			const result = await resource.execute(ctx.db, operation, {
-				id,
-				query: input,
-				data: operation === "update" ? input["patch"] : input
+		for (const { info, operation } of tableTools(resource, defs)) {
+			const ref = {
+				info,
+				meta: void 0
+			};
+			register({
+				...ref,
+				async call(args, ctx) {
+					const input = args ?? {};
+					const refusal = await refused(ref, input, ctx);
+					if (refusal) return refusal;
+					const id = resource.keyParam ? input[resource.keyParam] : void 0;
+					const result = await resource.execute(ctx.db, operation, {
+						id,
+						query: input,
+						data: operation === "update" ? input["patch"] : input
+					});
+					if (!result.ok) return failure(result.error);
+					return textResult(operation === "delete" ? { deleted: true } : result.data);
+				}
 			});
-			if (!result.ok) return failure(result.error);
-			return textResult(operation === "delete" ? { deleted: true } : result.data);
-		});
+		}
 	}
 	const addTool = (tool) => {
-		register(tool.info, async (args, ctx) => {
-			let value = args ?? {};
-			if (tool.input) {
-				const parsed = await validate(tool.input, value, "arguments");
-				if (!parsed.ok) return failure(parsed.error);
-				value = parsed.data;
+		const ref = {
+			info: tool.info,
+			meta: tool.meta
+		};
+		register({
+			...ref,
+			async call(args, ctx) {
+				let value = args ?? {};
+				if (tool.input) {
+					const parsed = await validate(tool.input, value, "arguments");
+					if (!parsed.ok) return failure(parsed.error);
+					value = parsed.data;
+				}
+				const refusal = await refused(ref, value, ctx);
+				if (refusal) return refusal;
+				const outcome = await settle(() => tool.run(value, ctx));
+				return outcome.ok ? textResult(outcome.data) : failure(outcome.error);
 			}
-			const outcome = await settle(() => tool.run(value, ctx));
-			return outcome.ok ? textResult(outcome.data) : failure(outcome.error);
 		});
 	};
 	for (const tool of options.tools ?? []) addTool(tool);
 	const listTools = () => [...registry.values()].map((entry) => entry.info);
+	const visibleTools = async (ctx) => {
+		const entries = [...registry.values()];
+		const shown = await Promise.all(entries.map((entry) => isVisible(entry, ctx)));
+		return entries.filter((_, index) => shown[index]).map((e) => e.info);
+	};
 	const authorizationServers = () => options.authorizationServers ?? [fromSupabaseUrl(server.env.url)];
 	const resourceOf = (request) => {
 		if (typeof options.resource === "function") return options.resource(request);
@@ -233,30 +319,76 @@ function createMcp(sb, options) {
 		const resource = new URL(resourceOf(request));
 		return `${resource.origin}${WELL_KNOWN}${resource.pathname.replace(/\/$/, "")}`;
 	};
-	const call = async (name, args, ctx) => {
+	const invoke = async (name, args, ctx, checkVisible = true) => {
 		const entry = registry.get(name);
-		if (!entry) return failure(dbError("not_found", `Unknown tool "${name}"`));
 		try {
+			if (!entry || checkVisible && !await isVisible(entry, ctx)) return failure(dbError("not_found", `Unknown tool "${name}"`));
 			return await entry.call(args, ctx);
 		} catch (cause) {
 			return failure(dbError("unexpected", expose && cause instanceof Error ? cause.message : "The tool failed"));
 		}
 	};
+	const isRefusal = (value) => "refusal" in value;
+	const call = async (name, args, ctx) => {
+		const outcome = await invoke(name, args, ctx);
+		return isRefusal(outcome) ? failure(dbError("forbidden", outcome.refusal)) : outcome;
+	};
+	const scopes = (options.scopes ?? []).filter((scope) => scope !== "offline_access");
+	const serverInfo = {
+		name: options.name,
+		version: options.version,
+		...options.title ? { title: options.title } : {}
+	};
+	const capabilities = { tools: { listChanged: false } };
+	const unauthorized = (request) => {
+		const response = unauthorizedResponse(request, { resourceMetadataUrl: metadataUrl(request) });
+		if (scopes.length > 0) response.headers.set("www-authenticate", `${response.headers.get("www-authenticate") ?? "Bearer"}, scope=${quoted(scopes.join(" "))}`);
+		return response;
+	};
+	const forbidden = (request, message, needed = [], id = null) => {
+		const all = [.../* @__PURE__ */ new Set([...scopes, ...needed])];
+		const challenge = [
+			"Bearer error=\"insufficient_scope\"",
+			`error_description=${quoted(message)}`,
+			...all.length > 0 ? [`scope=${quoted(all.join(" "))}`] : [],
+			`resource_metadata=${quoted(metadataUrl(request))}`
+		].join(", ");
+		const response = rpcError(id, INVALID_REQUEST, message, 403);
+		response.headers.set("www-authenticate", challenge);
+		return response;
+	};
+	const unsupportedVersion = (id, requested) => rpcError(id, UNSUPPORTED_PROTOCOL_VERSION, "Unsupported protocol version", 400, {
+		supported: [...SUPPORTED_VERSIONS],
+		requested
+	});
+	/** 2026-07-28 requests carry their version and capabilities, mirrored in headers. */
+	const checkModern = (message, header, headers) => {
+		const meta = message.params?.["_meta"];
+		const version = isObject(meta) ? meta[META_VERSION] : void 0;
+		if (!isObject(meta) || typeof version !== "string" || !isObject(meta[META_CAPABILITIES])) return rpcError(message.id, INVALID_PARAMS, `Requests need _meta["${META_VERSION}"] and _meta["${META_CAPABILITIES}"]`, 400);
+		if (version !== MCP_PROTOCOL_VERSION) return unsupportedVersion(message.id, version);
+		const mismatch = (detail) => rpcError(message.id, HEADER_MISMATCH, `Header mismatch: ${detail}`, 400);
+		if (header !== version) return mismatch(`MCP-Protocol-Version must be ${version}`);
+		if (headers.get("mcp-method") !== message.method) return mismatch(`Mcp-Method must be ${message.method}`);
+		const name = message.params?.["name"];
+		if (message.method === "tools/call" && typeof name === "string") {
+			const sent = headers.get("mcp-name");
+			if (sent === null || headerName(sent) !== name) return mismatch(`Mcp-Name must be ${name}`);
+		}
+	};
 	const handler = async (request) => {
 		const origin = request.headers.get("origin");
 		if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) return rpcError(null, INVALID_REQUEST, "Origin not allowed", 403);
+		if (options.allowedHosts && !hostAllowed(request, options.allowedHosts)) return rpcError(null, INVALID_REQUEST, "Host not allowed", 403);
 		if (request.method !== "POST") return new Response(null, {
 			status: 405,
 			headers: { allow: "POST" }
 		});
-		const version = request.headers.get("mcp-protocol-version");
-		if (version && !SUPPORTED_VERSIONS.has(version)) return rpcError(null, INVALID_REQUEST, `Unsupported MCP-Protocol-Version ${version}`, 400);
+		const header = request.headers.get("mcp-protocol-version");
+		if (header && !SUPPORTED_VERSIONS.includes(header)) return unsupportedVersion(null, header);
 		const ctx = await server.context(request);
 		const denied = guard(ctx.auth, options.allow, options.aal);
-		if (denied) {
-			if (denied.kind === "unauthorized") return unauthorizedResponse(request, { resourceMetadataUrl: metadataUrl(request) });
-			return rpcError(null, INVALID_REQUEST, denied.message, 403);
-		}
+		if (denied) return denied.kind === "unauthorized" ? unauthorized(request) : forbidden(request, denied.message);
 		let message;
 		try {
 			message = await request.json();
@@ -264,43 +396,73 @@ function createMcp(sb, options) {
 			return rpcError(null, PARSE_ERROR, "Parse error", 400);
 		}
 		if (!isRpcRequest(message)) return rpcError(null, INVALID_REQUEST, "Expected one JSON-RPC 2.0 message", 400);
+		const meta = message.params?.["_meta"];
+		const modern = isObject(meta) && meta[META_VERSION] !== void 0 || header === MCP_PROTOCOL_VERSION;
+		if (modern) {
+			const invalid = checkModern(message, header, request.headers);
+			if (invalid) return invalid;
+		}
 		if (message.id === void 0) return new Response(null, { status: 202 });
+		const toolContext = () => withExtra(ctx, {
+			request,
+			signal: request.signal
+		});
 		const reply = (result) => Response.json({
 			jsonrpc: "2.0",
 			id: message.id,
-			result
+			result: modern ? {
+				...result,
+				resultType: "complete",
+				_meta: { [META_SERVER_INFO]: serverInfo }
+			} : result
 		});
+		const notFound = () => rpcError(message.id, METHOD_NOT_FOUND, `Method not found: ${message.method}`, modern ? 404 : 200);
 		switch (message.method) {
+			case "server/discover": return reply({
+				supportedVersions: [...SUPPORTED_VERSIONS],
+				capabilities,
+				...options.instructions ? { instructions: options.instructions } : {},
+				ttlMs: LIST_TTL_MS,
+				cacheScope: "private"
+			});
 			case "initialize": {
+				if (modern) return notFound();
 				const requested = message.params?.["protocolVersion"];
 				return reply({
-					protocolVersion: typeof requested === "string" && SUPPORTED_VERSIONS.has(requested) ? requested : MCP_PROTOCOL_VERSION,
-					capabilities: { tools: { listChanged: false } },
-					serverInfo: {
-						name: options.name,
-						version: options.version,
-						...options.title ? { title: options.title } : {}
-					},
+					protocolVersion: typeof requested === "string" && LEGACY_VERSIONS.includes(requested) ? requested : LEGACY_VERSIONS[0],
+					capabilities,
+					serverInfo,
 					...options.instructions ? { instructions: options.instructions } : {}
 				});
 			}
-			case "ping": return reply({});
-			case "tools/list": return reply({ tools: listTools() });
+			case "ping": return modern ? notFound() : reply({});
+			case "tools/list": return reply({
+				tools: await visibleTools(toolContext()),
+				...modern ? {
+					ttlMs: LIST_TTL_MS,
+					cacheScope: "private"
+				} : {}
+			});
 			case "tools/call": {
 				const name = message.params?.["name"];
-				if (typeof name !== "string" || !registry.has(name)) return rpcError(message.id, INVALID_PARAMS, `Unknown tool ${JSON.stringify(name)}`);
-				return reply(await call(name, message.params?.["arguments"], withExtra(ctx, {
-					request,
-					signal: request.signal
-				})));
+				const entry = typeof name === "string" ? registry.get(name) : void 0;
+				const context = toolContext();
+				if (!entry || !await isVisible(entry, context)) return rpcError(message.id, INVALID_PARAMS, `Unknown tool ${JSON.stringify(name)}`);
+				const outcome = await invoke(entry.info.name, message.params?.["arguments"], context, false);
+				if (!isRefusal(outcome)) return reply(outcome);
+				if (outcome.scopes.length > 0) return forbidden(request, outcome.refusal, outcome.scopes, message.id);
+				return reply(failure(dbError("forbidden", outcome.refusal)));
 			}
-			default: return rpcError(message.id, METHOD_NOT_FOUND, `Method not found: ${message.method}`);
+			default: return notFound();
 		}
 	};
-	const metadata = (request) => resourceMetadataResponse(request, {
+	const metadata = (request) => Response.json({
 		resource: resourceOf(request),
-		authorizationServers: [...authorizationServers()]
-	});
+		authorization_servers: [...authorizationServers()],
+		bearer_methods_supported: ["header"],
+		...scopes.length > 0 ? { scopes_supported: scopes } : {},
+		...options.resourceDocumentation === void 0 ? {} : { resource_documentation: options.resourceDocumentation }
+	}, { headers: { "access-control-allow-origin": "*" } });
 	const mcp = extendServer(server, {
 		get tools() {
 			return listTools();

package/dist/{mfa-CpogP66z.js → mfa-BxoR1RkN.js}

@@ -1,4 +1,6 @@
 import { n as dbError } from "./errors-Bl3rkOzo.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { n as decodeJwtPayload } from "./base64-CQeB1eSf.js";
 import { DEFAULT_COOKIE_OPTIONS, createChunks, isChunkLike, parseCookieHeader, serializeCookieHeader, stringFromBase64URL, stringToBase64URL } from "@supabase/ssr";
 import { extractCredentials, verifyCredentials } from "@supabase/server/core";
 //#region src/auth/impersonation.ts
@@ -21,6 +23,65 @@ function impersonatorOf(claims) {
 	} : { id: sub };
 }
 //#endregion
+//#region src/auth/actor.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function copyAct(level) {
+	const entries = Object.entries(level).map(([key, value]) => [key, key === "act" && isRecord(value) ? copyAct(value) : value]);
+	return Object.fromEntries(entries);
+}
+/**
+* Reads only `act` and `client_id`, the way PermDock's `actorOf` does. An
+* `act` that is not a chain of objects each with a non-empty `sub` is
+* `{ ok: false }`: the session must not pass as the user alone.
+*/
+function actorOf(claims) {
+	const outer = claims["act"];
+	if (outer !== void 0) {
+		let level = outer;
+		while (level !== void 0) {
+			if (!isRecord(level)) return {
+				ok: false,
+				reason: "invalid-chain"
+			};
+			const sub = level["sub"];
+			if (typeof sub !== "string" || sub === "") return {
+				ok: false,
+				reason: "invalid-chain"
+			};
+			level = level["act"];
+		}
+		if (!isRecord(outer) || typeof outer["sub"] !== "string") return {
+			ok: false,
+			reason: "invalid-chain"
+		};
+		return {
+			ok: true,
+			actor: {
+				id: outer["sub"],
+				kind: "oauth-client",
+				chain: copyAct(outer)
+			}
+		};
+	}
+	const client = claims["client_id"];
+	if (typeof client === "string" && client !== "") return {
+		ok: true,
+		actor: {
+			id: client,
+			kind: "oauth-client"
+		}
+	};
+	return { ok: true };
+}
+/** The OAuth `scope` claim (a space-separated string or a list); `undefined` when empty. */
+function delegationOf(claims) {
+	const scope = claims["scope"];
+	const scopes = typeof scope === "string" ? scope.split(/\s+/u).filter(Boolean) : Array.isArray(scope) ? scope.filter((item) => typeof item === "string") : [];
+	return scopes.length > 0 ? { scopes } : void 0;
+}
+//#endregion
 //#region src/auth/refresh.ts
 /**
 * How long a finished refresh is reused for requests still carrying the old
@@ -190,20 +251,9 @@ function applyCookieWrites(cookies, writes) {
 }
 //#endregion
 //#region src/auth/resolve.ts
-function decodePayload(token) {
-	const part = token.split(".")[1];
-	if (!part) return void 0;
-	try {
-		const json = atob(part.replace(/-/g, "+").replace(/_/g, "/"));
-		const parsed = JSON.parse(json);
-		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
 function expiryOf(session) {
 	if (typeof session.expires_at === "number") return session.expires_at;
-	const exp = decodePayload(session.access_token)?.["exp"];
+	const exp = decodeJwtPayload(session.access_token)?.["exp"];
 	return typeof exp === "number" ? exp : void 0;
 }
 function serverEnv(options) {
@@ -257,7 +307,7 @@ async function verify(credentials, modes, options, source) {
 	const memo = token ? memoFor(options) : void 0;
 	if (token && memo) {
 		const hit = remembered(memo, token, Math.floor((options.now ?? Date.now)() / 1e3));
-		if (hit) return checkClaims({
+		if (hit) return checkUser({
 			...hit,
 			source
 		}, options);
@@ -270,11 +320,17 @@ async function verify(credentials, modes, options, source) {
 		user: state.user,
 		expiresAt: state.expiresAt
 	});
-	return checkClaims(state, options);
+	return checkUser(state, options);
 }
 /** Validates a user's claims against `options.claims`, keeping every JWT claim. */
 async function checkClaims(state, options) {
-	if (state.kind !== "user" || !options.claims) return state;
+	if (state.kind !== "user") return state;
+	if (!actorOf(state.claims).ok) return {
+		kind: "invalid",
+		reason: "actor",
+		error: dbError("unauthorized", "The token's act claim is not a chain of actors with a sub", { code: "ACTOR_INVALID" })
+	};
+	if (!options.claims) return state;
 	let outcome = options.claims["~standard"].validate(state.claims);
 	if (outcome instanceof Promise) outcome = await outcome;
 	if (outcome.issues) {
@@ -297,12 +353,31 @@ async function checkClaims(state, options) {
 		}
 	} : state;
 }
+const warnedMetadata = /* @__PURE__ */ new WeakSet();
+/** Claims first, then `user_metadata`, whose failure never invalidates the session. */
+async function checkUser(state, options) {
+	const checked = await checkClaims(state, options);
+	const schema = options.userMetadata;
+	if (checked.kind !== "user" || !schema) return checked;
+	const { profile: _untrusted, ...user } = checked;
+	let outcome = schema["~standard"].validate(checked.user.userMetadata ?? checked.claims.user_metadata ?? {});
+	if (outcome instanceof Promise) outcome = await outcome;
+	if (!outcome.issues) return {
+		...user,
+		profile: outcome.value
+	};
+	if (!warnedMetadata.has(schema)) {
+		warnedMetadata.add(schema);
+		(options.logger ?? consoleLogger).warn("user_metadata does not match sb.userMetadata(schema); session.profile is undefined", { paths: outcome.issues.map((issue) => issue.path?.map((segment) => typeof segment === "object" ? String(segment.key) : String(segment)).join(".") ?? "") });
+	}
+	return user;
+}
 async function verifyOnce(credentials, modes, options, source) {
 	const { data, error } = await verifyCredentials(credentials, {
 		auth: modes,
 		env: serverEnv(options),
-		...options.audience !== void 0 ? { audience: options.audience } : {},
-		...options.issuer !== void 0 ? { issuer: options.issuer } : {}
+		...options.audience === void 0 ? {} : { audience: options.audience },
+		...options.issuer === void 0 ? {} : { issuer: options.issuer }
 	});
 	if (error) {
 		const kind = error.code === "JWKS_FETCH_FAILED" ? "network" : error.status >= 500 ? "unexpected" : "unauthorized";
@@ -373,7 +448,7 @@ async function resolveAuth(request, options) {
 			kind: "invalid",
 			reason: state.reason ?? "token",
 			error: state.error
-		} : await checkClaims(state, options), cookies);
+		} : await checkUser(state, options), cookies);
 	}
 	const credentials = extractCredentials(request);
 	if (credentials.token) return resolution(await verify({
@@ -401,7 +476,7 @@ async function resolveAuth(request, options) {
 			token: session.access_token,
 			apikey: null
 		}, ["user"], options, "cookie");
-		if (state.kind !== "invalid" || state.reason === "claims" || state.error.kind === "network") return resolution(state, cookies);
+		if (state.kind !== "invalid" || state.reason !== "token" || state.error.kind === "network") return resolution(state, cookies);
 		if (!options.refresh) return resolution({
 			kind: "anon",
 			reason: "signed_out"
@@ -453,8 +528,8 @@ function authContext(auth) {
 				actor: {
 					id: auth.user.id,
 					kind: "user",
-					...auth.user.role !== void 0 ? { role: auth.user.role } : {},
-					...auth.user.email !== void 0 ? { email: auth.user.email } : {},
+					...auth.user.role === void 0 ? {} : { role: auth.user.role },
+					...auth.user.email === void 0 ? {} : { email: auth.user.email },
 					...impersonator ? { impersonator: impersonator.id } : {}
 				},
 				claims: auth.claims
@@ -518,4 +593,4 @@ function checkAal(auth, required) {
 	});
 }
 //#endregion
-export { clientIp as a, applyCookieWrites as c, serializeCookie as d, sessionCookieName as f, impersonatorOf as g, actClaim as h, authContext as i, parseCookies as l, refreshSession as m, amrOf as n, resolveAuth as o, writeSession as p, checkAal as r, AUTH_CACHE_HEADERS as s, aalOf as t, readSession as u };
+export { actClaim as _, clientIp as a, applyCookieWrites as c, serializeCookie as d, sessionCookieName as f, delegationOf as g, actorOf as h, authContext as i, parseCookies as l, refreshSession as m, amrOf as n, resolveAuth as o, writeSession as p, checkAal as r, AUTH_CACHE_HEADERS as s, aalOf as t, readSession as u, impersonatorOf as v };

package/dist/{mfa-TVia554c.d.ts → mfa-x3V3vGh-.d.ts}

@@ -1,4 +1,4 @@
-import { p as DbError } from "./result-CTkCZ6JA.js";
+import { p as DbError } from "./result-c2OYgCV2.js";
 //#region src/auth/impersonation.d.ts
 /** The admin acting as the user, from the RFC 8693 `act` claim. */
 interface Impersonator {