unjwt 0.8.5 → 0.9.1

package/dist/session/index.mjs

@@ -1,73 +1,1425 @@
-import { thumbprint } from "../_chunks/algorithms.mjs";
+import { safeJsonParse } from "../_chunks/libs/unsecure.mjs";
+import { JWTError, isJWTError } from "../error.mjs";
+import { computeDurationInSeconds, expiredClaimMessage, isAsymmetricJWK, isCryptoKey, isJWK, isJWKSet, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK } from "../_chunks/jwt.mjs";
+import { quoteTokenValue } from "../_chunks/jwt2.mjs";
+import { importKey, resolveLimit, thumbprint } from "../_chunks/algorithms.mjs";
+import { PBES2_ALGORITHMS, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, isContentEncryptionAlgorithm, lengthOf } from "../_chunks/digest.mjs";
+import { sign, verify } from "../_chunks/jws.mjs";
+import { decrypt, encrypt } from "../_chunks/jwe.mjs";
 import { toPublicJWK } from "../_chunks/export.mjs";
 import { deriveJWKFromPassword, exportPEM, generateJWK, importPEM } from "../_chunks/jwk.mjs";
-import { createJWECodec, createJWSCodec, defineSession, invalidConfigError } from "../_chunks/codec-jws.mjs";
-import { webCookieJar } from "../_chunks/cookie.mjs";
-const PREFIX = "[unjwt/session]";
-const SESSIONS = /* @__PURE__ */ new WeakMap();
-const webSessionDriver = {
-	prefix: PREFIX,
-	state: (event) => {
-		if (isHanded(event)) return sessionsOf(event);
-		if (event.context) return contextSessions(event.context);
-		return sessionsOf(event.req ? webRequest(event.req) : event);
+import { parse, parseSetCookie, serialize } from "../_chunks/libs/cookie-es.mjs";
+const RESERVED_CLAIMS = [
+	"jti",
+	"iat",
+	"exp",
+	"nbf"
+];
+const SESSION_TYP = "session+jwt";
+const FORBIDDEN_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+const importedKeys = /* @__PURE__ */ new WeakMap();
+function invalidKeyError(message, cause) {
+	return new JWTError(message, "ERR_SESSION_KEY_INVALID", cause);
+}
+function invalidConfigError(message, cause) {
+	return new JWTError(message, "ERR_SESSION_CONFIG_INVALID", cause);
+}
+function invalidTokenError(message, cause) {
+	return new JWTError(message, "ERR_SESSION_TOKEN_INVALID", cause);
+}
+function readOnlyEventError(message) {
+	return new JWTError(message, "ERR_SESSION_READONLY_EVENT");
+}
+function expiredSessionError(options) {
+	const { id, createdAt, expiresAt } = options;
+	const exp = Math.floor(expiresAt / 1e3);
+	const iat = createdAt === void 0 ? void 0 : Math.floor(createdAt / 1e3);
+	return new JWTError(expiredClaimMessage(exp), "ERR_JWT_EXPIRED", {
+		jti: id,
+		iat,
+		exp
+	});
+}
+function readFailedError(cause, options) {
+	return new JWTError(`${options.prefix} Session could not be read: ${messageOf(cause)}`, "ERR_SESSION_READ_FAILED", cause);
+}
+function malformedHeaderError(header, options) {
+	return invalidTokenError(`${options.prefix} Invalid session token: the "${header}" header holds neither a token nor "Bearer <token>".`);
+}
+function rethrowAsInvalidToken(error, options) {
+	if (isJWTError(error, "ERR_JWT_EXPIRED") || isJWTError(error, "ERR_SESSION_READ_FAILED")) throw error;
+	throw invalidTokenError(`${options.prefix} Invalid session token: ${messageOf(error)}`, error);
+}
+const TOKEN = /^[!#$%&'*+\-.^_`|~\w]+$/;
+const CHUNK_SUFFIX = /\.\d+$/;
+function assertSessionName(name, options) {
+	if (!isToken(name)) throw invalidConfigError(`${options.prefix} Session "name" must be a valid cookie name (got ${quoteTokenValue(name)}).`);
+	if (CHUNK_SUFFIX.test(name)) throw invalidConfigError(`${options.prefix} Session "name" ${quoteTokenValue(name)} cannot end in a dot and digits.`);
+}
+function isToken(value) {
+	return typeof value === "string" && TOKEN.test(value);
+}
+function assertCookiePrefix(name, attrs, options) {
+	const lower = name.toLowerCase();
+	const host = lower.startsWith("__host-");
+	if (!host && !lower.startsWith("__secure-")) return;
+	const rule = host ? "\"__Host-\" cookie must be Secure, with Path=/ and no Domain" : "\"__Secure-\" cookie must be Secure";
+	if (!attrs.secure || host && (attrs.domain !== void 0 || attrs.path !== void 0 && attrs.path !== "/")) throw invalidConfigError(`${options.prefix} Session ${quoteTokenValue(name)}: a ${rule}.`);
+}
+function assertRolling(config, options) {
+	const { rolling } = config;
+	if (rolling === void 0) return;
+	if (config.maxAge === void 0) throw invalidConfigError(`${options.prefix} "rolling" needs a "maxAge" to extend.`);
+	if (rolling === true) return;
+	if (!isExpiresIn(rolling)) throw new JWTError(`${options.prefix} "rolling" must be true or a duration.`, "ERR_INVALID_OPTION");
+	if (computeDurationInSeconds(rolling) >= computeDurationInSeconds(config.maxAge)) throw invalidConfigError(`${options.prefix} "rolling" must be shorter than "maxAge".`);
+}
+function assertKeyMaterial(key, options) {
+	if (typeof key === "string") throw invalidKeyError(`${options.prefix} Session "key" cannot be a string, use deriveJWKFromPassword().`);
+	if (!key) throw invalidKeyError(`${options.prefix} Session "key" is required.`);
+}
+async function assertImportableKey(key, options) {
+	if (!isJWK(key)) return;
+	const alg = key.alg ?? options.alg;
+	if (key.kty !== "oct" && !alg) return;
+	let imports = importedKeys.get(key);
+	if (!imports) {
+		imports = /* @__PURE__ */ new Map();
+		importedKeys.set(key, imports);
+	}
+	const slot = alg ?? "";
+	let pending = imports.get(slot);
+	if (!pending) {
+		pending = importKey(key, { alg }).then(() => void 0);
+		imports.set(slot, pending);
+	}
+	try {
+		await pending;
+	} catch (error) {
+		if (imports.get(slot) === pending) imports.delete(slot);
+		throw invalidKeyError(`${options.prefix} Invalid session key: ${messageOf(error)}`, error);
+	}
+}
+function sessionTyp(configured) {
+	return typeof configured === "string" && configured ? configured : SESSION_TYP;
+}
+function resolveExpiresAt(createdAt, options) {
+	return options.maxAge === void 0 ? void 0 : createdAt + computeDurationInSeconds(options.maxAge) * 1e3;
+}
+function sessionRequiredClaims(configured, options) {
+	const required = /* @__PURE__ */ new Set([
+		...configured || [],
+		"jti",
+		"iat"
+	]);
+	if (options.maxAge !== void 0) required.add("exp");
+	return [...required];
+}
+function sanitizeSessionUpdate(update, options) {
+	if (!isPlainObject(update)) throw new JWTError(`${options.prefix} Session data must be a plain object.`, "ERR_INVALID_OPTION");
+	const sanitized = Object.create(null);
+	for (const key of Object.keys(update)) {
+		if (FORBIDDEN_KEYS.includes(key)) throw new JWTError(`${options.prefix} Session data cannot carry the key "${key}".`, "ERR_INVALID_OPTION");
+		if (RESERVED_CLAIMS.includes(key)) continue;
+		sanitized[key] = update[key];
+	}
+	return sanitized;
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isExpiresIn(value) {
+	return typeof value === "number" || typeof value === "string";
+}
+function createSessionCodec(spec) {
+	const { prefix } = spec;
+	const now = (config) => spec.issueOptions(config)?.currentDate?.getTime() ?? Date.now();
+	const openWith = async (config, token, key, opening) => {
+		const options = spec.openOptions(config);
+		const payload = await spec.open(config, token, key, sessionOpenOptions({
+			maxAge: config.maxAge,
+			requiredClaims: options?.requiredClaims,
+			typ: spec.issueOptions(config)?.protectedHeader?.typ,
+			algorithms: opening.algorithms
+		})).catch((error) => rethrowOpenFailure(error, {
+			lookup: opening.lookup,
+			prefix
+		}));
+		const clock = {
+			now: now(config),
+			clockTolerance: options?.clockTolerance
+		};
+		assertNotFromTheFuture(payload, {
+			...clock,
+			prefix
+		});
+		const opened = openedSession(payload, { maxAge: config.maxAge });
+		assertNotPastMaxAge(opened, clock);
+		return opened;
+	};
+	return {
+		family: spec.family,
+		defaultName: spec.defaultName,
+		now,
+		keys: (config) => {
+			const { issueKey, issueAlg, key, algorithms } = spec.resolveKeys(config);
+			const hook = spec.lookup(config);
+			const keyFor = (args) => hook ? ({ header }) => lookUpKey(hook, {
+				header,
+				...args,
+				config
+			}, { prefix }) : key;
+			const importable = hook ? [] : isJWKSet(key) ? key.keys : [key];
+			const opening = {
+				algorithms,
+				lookup: hook !== void 0
+			};
+			const assertOpenKeys = async () => {
+				for (const entry of importable) await assertImportableKey(entry, {
+					alg: void 0,
+					prefix
+				});
+			};
+			return {
+				assertKeys: async () => {
+					await assertImportableKey(issueKey, {
+						alg: issueAlg ?? spec.issueOptions(config)?.alg,
+						prefix
+					});
+					await assertOpenKeys();
+				},
+				issue: (state) => spec.issue(config, sessionPayload(state), issueKey, issueAlg),
+				opener: (args) => {
+					const keyed = keyFor(args);
+					return (token) => openWith(config, token, keyed, opening);
+				},
+				open: async (token, args) => {
+					await assertOpenKeys();
+					return openWith(config, token, keyFor(args), opening);
+				}
+			};
+		}
+	};
+}
+function sessionIssueOptions(options) {
+	return Object.assign({}, options, {
+		expiresIn: void 0,
+		expiresAt: void 0,
+		notBeforeIn: void 0,
+		notBeforeAt: void 0,
+		protectedHeader: {
+			...options?.protectedHeader,
+			typ: sessionTyp(options?.protectedHeader?.typ)
+		}
+	});
+}
+function sessionOpenOptions(options) {
+	const { maxAge, requiredClaims, typ, algorithms } = options;
+	return {
+		requiredClaims: sessionRequiredClaims(requiredClaims, { maxAge }),
+		typ: sessionTyp(typ),
+		maxTokenAge: void 0,
+		algorithms,
+		payload: "json",
+		validateClaims: true
+	};
+}
+function sessionPayload(state) {
+	const iat = Math.floor(state.createdAt / 1e3);
+	const exp = state.expiresAt ? Math.floor(state.expiresAt / 1e3) : void 0;
+	const payload = {};
+	for (const key of Object.keys(state.data)) if (!RESERVED_CLAIMS.includes(key)) payload[key] = state.data[key];
+	payload.jti = state.id;
+	payload.iat = iat;
+	if (exp) payload.exp = exp;
+	return payload;
+}
+function assertNotFromTheFuture(payload, options) {
+	if (payload.iat > Math.floor(options.now / 1e3) + toleranceSeconds(options.clockTolerance)) throw invalidTokenError(`${options.prefix} Invalid session token: "iat" is in the future (${(/* @__PURE__ */ new Date(payload.iat * 1e3)).toISOString()}).`);
+}
+function assertNotPastMaxAge(opened, options) {
+	const { expiresAt } = opened;
+	if (expiresAt === void 0) return;
+	if (expiresAt <= options.now - toleranceSeconds(options.clockTolerance) * 1e3) throw expiredSessionError({
+		id: opened.id,
+		createdAt: opened.createdAt,
+		expiresAt
+	});
+}
+async function lookUpKey(hook, args, options) {
+	try {
+		return await hook(args);
+	} catch (error) {
+		throw readFailedError(error, options);
+	}
+}
+function rethrowOpenFailure(error, options) {
+	if (options.lookup && isJWTError(error, "ERR_JWK_INVALID")) throw readFailedError(error, options);
+	return rethrowAsInvalidToken(error, options);
+}
+function toleranceSeconds(clockTolerance) {
+	return clockTolerance === void 0 ? 0 : computeDurationInSeconds(clockTolerance);
+}
+function openedSession(payload, options) {
+	const data = Object.create(null);
+	for (const key of Object.keys(payload)) {
+		if (RESERVED_CLAIMS.includes(key)) continue;
+		data[key] = payload[key];
+	}
+	const createdAt = payload.iat * 1e3;
+	const exp = payload.exp ? payload.exp * 1e3 : void 0;
+	const bound = resolveExpiresAt(createdAt, options);
+	return {
+		id: payload.jti,
+		createdAt,
+		expiresAt: exp === void 0 || bound === void 0 ? exp ?? bound : Math.min(exp, bound),
+		data
+	};
+}
+function assertJWSKeyPair(pair, prefix) {
+	const { privateKey, publicKey } = pair;
+	if (!isPrivateJWK(privateKey) && !isCryptoKeyOf(privateKey, "private")) throw invalidKeyError(`${prefix} Invalid JWS session key: "privateKey" must be a private JWK or a private CryptoKey.`, pair);
+	if (!isPublicHalf(publicKey)) throw invalidKeyError(`${prefix} Invalid JWS session key: "publicKey" must be a public JWK, a non-empty list or JWK Set of them, or a public CryptoKey.`, pair);
+}
+function assertVerifiesIssued(entries, options) {
+	const { alg, by, list, rules, prefix } = options;
+	const served = entries.map(({ key }) => rules.own(key) ?? rules.carried(key));
+	if (served.some((algorithms) => algorithms.includes(alg))) return;
+	const [{ key }] = entries;
+	const own = list ? void 0 : rules.own(key);
+	throw invalidKeyError(`${prefix} The session key "publicKey" ${own ? `names "${(isJWK(key) ? key.alg : void 0) ?? own[0]}"` : `serves ${[...new Set(served.flat())].join(", ") || "no algorithm"}`}, not the "${alg}" that ${by}.`, list ? entries.map((entry) => entry.key) : key);
+}
+function isPublicHalf(half) {
+	if (isCryptoKeyOf(half, "public") || isPublicJWK(half)) return true;
+	const keys = Array.isArray(half) ? half : isJWKSet(half) ? half.keys : void 0;
+	return keys !== void 0 && keys.length > 0 && keys.every((candidate) => isPublicJWK(candidate));
+}
+function isCryptoKeyOf(key, type) {
+	return isCryptoKey(key) && key.type === type;
+}
+function sessionKeySetEntries(keys, options) {
+	const { rules, prefix } = options;
+	if (keys.length === 0) throw invalidKeyError(`${prefix} The session key is an empty JWK Set.`);
+	const entries = keys.map((key, index) => {
+		const subject = `The session key "keys[${index}]"${kidLabel(key)}`;
+		if (!isSymmetricJWK(key)) throw invalidKeyError(`${prefix} ${subject} must be an "oct" JWK.`, key);
+		return {
+			key,
+			subject,
+			pin: index ? void 0 : options.pin
+		};
+	});
+	const limit = resolveLimit(options.limits, "keyCandidates");
+	for (const entry of entries) {
+		if (entry.key.kid !== void 0) continue;
+		for (const alg of servedBy(entry, options)) {
+			const met = entries.filter(({ key }) => rules.own(key)?.includes(alg) ?? true).length;
+			if (met > limit) throw invalidConfigError(`${prefix} ${entry.subject} carries no "kid", so a token of "${alg}" meets ${met} keys, over the limit of ${limit} ("${rules.limitPath}").`);
+		}
+	}
+	return entries;
+}
+function assertPinnedKey(entry, options) {
+	const { rules, prefix } = options;
+	const { key, pin, subject } = entry;
+	const own = rules.own(key);
+	if (own === void 0 && (!pin || !options.pinned)) throw invalidConfigError(`${prefix} ${subject} names no algorithm, set ${rules.hint}${isJWK(key) ? ", or its \"alg\"" : ""}.`);
+	const served = own ?? rules.carried(key);
+	if (!pin || served.includes(pin)) return;
+	throw invalidKeyError(`${prefix} ${subject} serves ${served.join(", ") || "no algorithm"}, not the "${pin}" that ${entry.pinnedBy ?? `"${rules.pinPath}" pins`}.`, key);
+}
+function servedAlgorithms(entries, options) {
+	const { rules, listed, prefix } = options;
+	const { listPath } = rules;
+	if (listed?.length === 0) throw invalidConfigError(`${prefix} "${listPath}" is empty, list the algorithms the session keys serve or leave it unset.`);
+	const all = /* @__PURE__ */ new Set();
+	const each = entries.map((entry) => {
+		const served = servedBy(entry, options);
+		if (served.length === 0) throw unservedKeyError(entry, {
+			rules,
+			prefix
+		});
+		for (const alg of served) all.add(alg);
+		return served;
+	});
+	for (const alg of listed ?? []) {
+		if (all.has(alg)) continue;
+		if (!options.lookup) throw invalidConfigError(`${prefix} "${listPath}" lists "${alg}", which no session key serves. Remove it, or add a key for it.`);
+		all.add(alg);
+	}
+	return {
+		each,
+		all: [...all]
+	};
+}
+function isKeyPair(key) {
+	return typeof key === "object" && key !== null && ("privateKey" in key || "publicKey" in key);
+}
+function kidLabel(key) {
+	return isJWK(key) && key.kid !== void 0 ? ` (kid ${quoteTokenValue(key.kid)})` : "";
+}
+function octBits(key) {
+	return Math.floor(key.k.length * 6 / 8) * 8;
+}
+function servedBy(entry, options) {
+	const { rules, listed } = options;
+	return rules.own(entry.key) ?? rules.carried(entry.key).filter((alg) => alg === entry.pin || listed?.includes(alg));
+}
+function unservedKeyError(entry, options) {
+	const { rules, prefix } = options;
+	const carried = rules.own(entry.key) ? [] : rules.carried(entry.key);
+	if (carried.length === 0) return invalidKeyError(`${prefix} ${entry.subject} serves no algorithm.`, entry.key);
+	return invalidConfigError(`${prefix} ${entry.subject} names no algorithm, list one it serves (${carried.join(", ")}) in "${rules.listPath}", or set its "alg".`);
+}
+const JWS_KEY_RULES = {
+	own: (key) => {
+		if (!isJWK(key)) return void 0;
+		const inferred = inferJWSAllowedAlgorithms(key);
+		return key.alg ? inferred ?? [] : inferred;
 	},
-	header: (event, name) => isHanded(event) ? void 0 : requestHeaders(event).get(name),
-	cookies: (event) => isHanded(event) ? { read: () => void 0 } : webCookieJar(requestHeaders(event), event.res),
-	handed: (event) => isHanded(event) ? { token: event.token } : void 0
+	carried: (key) => {
+		if (isCryptoKey(key)) return inferJWSAllowedAlgorithms(key) ?? [];
+		if (isJWK(key) && key.kty === "RSA") return RSA_SIGNATURES;
+		if (!isSymmetricJWK(key)) return [];
+		const bits = octBits(key);
+		return HMAC_SIGNATURES.filter((alg) => bits >= Number(alg.slice(2)));
+	},
+	pinPath: "jws.signOptions.alg",
+	hint: "\"jws.signOptions.alg\"",
+	listPath: "jws.verifyOptions.algorithms",
+	limitPath: "jws.verifyOptions.limits.keyCandidates"
 };
-function isHanded(event) {
+function resolveSessionKeys$1(key, options) {
+	const { alg: pin, prefix } = options;
+	assertKeyMaterial(key, { prefix });
+	let issuing;
+	let entries;
+	let list;
+	let issued;
+	if (isCryptoKey(key) && key.type === "secret" || isSymmetricJWK(key)) {
+		issuing = {
+			key,
+			subject: "The session key",
+			pin
+		};
+		entries = [issuing];
+	} else if (isJWKSet(key)) {
+		const set = sessionKeySetEntries(key.keys, {
+			...options,
+			pin,
+			rules: JWS_KEY_RULES
+		});
+		[issuing] = set;
+		entries = set;
+	} else if (isKeyPair(key)) {
+		assertJWSKeyPair(key, prefix);
+		const half = key.publicKey;
+		list = Array.isArray(half) ? half : isJWKSet(half) ? half.keys : void 0;
+		const signing = namedAlgorithm(key.privateKey);
+		const alg = pin ?? signing;
+		if (alg) issued = {
+			alg,
+			by: pin ? `"${JWS_KEY_RULES.pinPath}" pins` : "the session key \"privateKey\" names"
+		};
+		issuing = {
+			key: key.privateKey,
+			subject: "The session key \"privateKey\"",
+			...pairPin(key.privateKey, {
+				pin,
+				named: list ? void 0 : namedAlgorithm(half),
+				by: "publicKey"
+			})
+		};
+		entries = (list ?? [half]).map((entry, index) => ({
+			key: entry,
+			subject: list ? `The session key "publicKey[${index}]"${kidLabel(entry)}` : "The session key \"publicKey\"",
+			...pairPin(entry, {
+				pin,
+				named: signing,
+				by: "privateKey"
+			})
+		}));
+	} else throw invalidJWSKeyError(key, prefix);
+	const pinning = {
+		rules: JWS_KEY_RULES,
+		pinned: true,
+		prefix
+	};
+	assertPinnedKey(issuing, pinning);
+	if (!list && issuing !== entries[0]) assertPinnedKey(entries[0], pinning);
+	if (issued) assertVerifiesIssued(entries, {
+		...issued,
+		list: list !== void 0,
+		rules: JWS_KEY_RULES,
+		prefix
+	});
+	const { each, all } = servedAlgorithms(entries, {
+		...options,
+		rules: JWS_KEY_RULES
+	});
+	const verifying = isJWKSet(key) ? key : list ? { keys: entries.flatMap(({ key: entry }, index) => servedCopies(entry, each[index])) } : entries[0].key;
+	const issueAlg = issuing.pin;
+	return {
+		issueKey: issuing.key,
+		issueAlg,
+		key: verifying,
+		algorithms: all
+	};
+}
+function namedAlgorithm(key) {
+	return isJWK(key) ? key.alg ?? JWS_KEY_RULES.own(key)?.[0] : void 0;
+}
+function pairPin(key, options) {
+	const { pin, named, by } = options;
+	if (pin || !named || JWS_KEY_RULES.own(key)) return { pin };
+	return {
+		pin: named,
+		pinnedBy: `the session key "${by}" names`
+	};
+}
+function servedCopies(key, served) {
+	if (!isJWK(key)) return [];
+	if (JWS_KEY_RULES.own(key)) return [key];
+	return served.map((alg) => ({
+		...key,
+		alg
+	}));
+}
+function invalidJWSKeyError(key, prefix) {
+	return invalidKeyError(isCryptoKey(key) || isAsymmetricJWK(key) ? `${prefix} Invalid JWS session key: an asymmetric key signs with its private half and verifies with its public half, pass both as { privateKey, publicKey }.` : `${prefix} Invalid JWS session key: expected an HMAC "oct" JWK, a JWK Set of them, a secret CryptoKey or a key pair.`, key);
+}
+const HMAC_SIGNATURES = [
+	"HS256",
+	"HS384",
+	"HS512"
+];
+const RSA_SIGNATURES = [
+	"RS256",
+	"RS384",
+	"RS512",
+	"PS256",
+	"PS384",
+	"PS512"
+];
+function createJWSCodec(options) {
+	const { prefix, defaultName } = options;
+	return createSessionCodec({
+		family: "jws",
+		prefix,
+		defaultName,
+		issueOptions: (config) => config.jws?.signOptions,
+		openOptions: (config) => config.jws?.verifyOptions,
+		resolveKeys: (config) => resolveSessionKeys$1(config.key, {
+			alg: config.jws?.signOptions?.alg,
+			listed: config.jws?.verifyOptions?.algorithms,
+			limits: config.jws?.verifyOptions?.limits,
+			lookup: typeof config.hooks?.onKeyLookup === "function",
+			prefix
+		}),
+		lookup: (config) => config.hooks?.onKeyLookup,
+		issue: (config, payload, key, alg) => {
+			const signOptions = config.jws?.signOptions;
+			const issuing = sessionIssueOptions(alg ? {
+				...signOptions,
+				alg
+			} : signOptions);
+			return sign(payload, key, issuing);
+		},
+		open: async (config, token, key, overrides) => {
+			const { payload } = await verify(token, key, {
+				...config.jws?.verifyOptions,
+				...overrides
+			});
+			return payload;
+		}
+	});
+}
+const DEFAULT_SESSION_COOKIE = /* @__PURE__ */ Object.freeze({
+	path: "/",
+	secure: true,
+	httpOnly: true,
+	sameSite: "lax"
+});
+const kSessionPending = Symbol("unjwt_session_pending");
+function sessionInstant(source) {
+	const now = source.codec.now(source.config);
+	return now - now % 1e3;
+}
+function mintSessionId(config) {
+	return config.generateId?.() || crypto.randomUUID();
+}
+function emptySession(binding) {
+	const createdAt = sessionInstant(binding);
+	return typedSession({
+		id: void 0,
+		createdAt,
+		expiresAt: resolveExpiresAt(createdAt, { maxAge: binding.config.maxAge }),
+		data: Object.create(null),
+		token: void 0,
+		source: binding.transport.source,
+		error: void 0
+	});
+}
+function storedSession(store) {
+	const state = store.get();
+	return state === void 0 ? void 0 : typedSession(state);
+}
+function blankSession() {
+	return typedSession({
+		expiresAt: void 0,
+		data: {}
+	});
+}
+function openSessionToken(keys, options) {
+	return keys.open(options.token, options.args).then((opened) => typedOpened({
+		...opened,
+		source: "token"
+	}));
+}
+function typedSession(state) {
+	return state;
+}
+function typedOpened(opened) {
+	return opened;
+}
+const CHUNK_MARKER = "__chunked__";
+const DEFAULT_CHUNK_MAX_LENGTH = 4e3;
+function readChunked(store, name) {
+	const main = store.read(name);
+	if (main === void 0) return void 0;
+	if (!main.startsWith("__chunked__")) return main;
+	const count = parseChunkCount(main);
+	if (count === 0) return void 0;
+	const parts = [];
+	for (let index = 1; index <= count; index++) {
+		const part = store.read(chunkName(name, index));
+		if (part === void 0) return void 0;
+		parts.push(part);
+	}
+	return parts.join("");
+}
+function writeChunked(store, name, value, options) {
+	const { attrs, chunkMaxLength, prefix } = options;
+	const max = chunkMaxLength && chunkMaxLength > 0 ? chunkMaxLength : DEFAULT_CHUNK_MAX_LENGTH;
+	const chunkCount = Math.ceil(value.length / max);
+	if (chunkCount > 16) throw invalidConfigError(`${prefix} Session token requires ${chunkCount} cookie chunks, exceeding the limit of 16.`);
+	const previousCount = parseChunkCount(store.read(name));
+	const firstSurplus = chunkCount <= 1 ? 1 : chunkCount + 1;
+	for (let index = firstSurplus; index <= previousCount; index++) expire(store, chunkName(name, index), attrs);
+	if (chunkCount <= 1) {
+		store.write(name, value, attrs);
+		return;
+	}
+	store.write(name, `${CHUNK_MARKER}${chunkCount}`, attrs);
+	for (let index = 1; index <= chunkCount; index++) store.write(chunkName(name, index), value.slice((index - 1) * max, index * max), attrs);
+}
+function removeChunked(store, name, options) {
+	const count = parseChunkCount(store.read(name));
+	expire(store, name, options.attrs);
+	for (let index = 1; index <= count; index++) expire(store, chunkName(name, index), options.attrs);
+}
+function setCookieValues(setCookies) {
+	const cookies = Object.create(null);
+	for (const setCookie of setCookies) {
+		const pair = setCookiePair(setCookie);
+		if (pair) cookies[pair.name] = decodeValue(pair.value);
+	}
+	return cookies;
+}
+function setCookieName(setCookie) {
+	return setCookiePair(setCookie)?.name;
+}
+function mirrorSetCookie(name, headers) {
+	const { from, to } = headers;
+	const isThisCookie = (line) => setCookieName(line) === name;
+	const lines = [...to.getSetCookie().filter((line) => !isThisCookie(line)), ...from.getSetCookie().filter((line) => isThisCookie(line))];
+	to.delete("set-cookie");
+	for (const line of lines) to.append("set-cookie", line);
+}
+function chunkName(name, index) {
+	return `${name}.${index}`;
+}
+function parseChunkCount(main) {
+	if (main === void 0 || !main.startsWith("__chunked__")) return 0;
+	const suffix = main.slice(11);
+	if (!/^\d+$/.test(suffix)) return 0;
+	const count = Number.parseInt(suffix, 10);
+	if (count < 1 || count > 16) return 0;
+	return count;
+}
+function expire(store, name, attrs) {
+	store.write(name, "", {
+		...attrs,
+		maxAge: 0,
+		expires: /* @__PURE__ */ new Date(0)
+	});
+}
+function setCookiePair(setCookie) {
+	const [pair = ""] = setCookie.split(";", 1);
+	const separator = pair.indexOf("=");
+	if (separator === -1) return void 0;
+	return {
+		name: pair.slice(0, separator).trim(),
+		value: pair.slice(separator + 1).trim()
+	};
+}
+function decodeValue(value) {
+	if (!value.includes("%")) return value;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+function resolveSessionTransport(driver, event, options) {
+	const handed = driver.handed?.(event);
+	if (handed) return {
+		source: "token",
+		read: () => handed.token,
+		readonly: false,
+		writable: () => true
+	};
+	const { name, cookie } = options;
+	const header = presentedHeader(driver, event, options);
+	if (cookie === false) return headerTransport(options, header);
+	const jar = driver.cookies(event);
+	if (header && (header.token === void 0 || header.token !== readChunked(jar, name))) return headerTransport(options, header);
+	const store = responseStore(jar);
+	const transport = {
+		source: "cookie",
+		read: () => cookieToken(jar, name),
+		readonly: !store,
+		writable: () => driver.writable?.(event) ?? true
+	};
+	if (!store) return transport;
+	const { attrs, chunkMaxLength } = cookie;
+	transport.write = (token, { expiresAt } = {}) => {
+		if (!transport.writable()) return false;
+		const written = expiresAt === void 0 ? { ...attrs } : {
+			...attrs,
+			expires: new Date(expiresAt),
+			maxAge: void 0
+		};
+		writeChunked(store, name, token, {
+			attrs: written,
+			chunkMaxLength,
+			prefix: driver.prefix
+		});
+		return true;
+	};
+	transport.drop = () => {
+		if (!transport.writable()) return false;
+		removeChunked(store, name, { attrs });
+		return true;
+	};
+	return transport;
+}
+function assertSessionTokenSource(transport, options) {
+	if (!transport.read) throw invalidConfigError(`${options.prefix} Session has no token source, enable "cookie" or "sessionHeader".`);
+}
+function assertSessionWritable(transport, options) {
+	const { operation, prefix } = options;
+	if (operation === "update" && transport.readonly) throw readOnlyEventError(`${prefix} Cannot update session on read-only event.`);
+	if (!transport.writable()) throw readOnlyEventError(`${prefix} Cannot update/clear session: the response was already sent.`);
+}
+function assertSessionHeader(header, options) {
+	if (header === void 0 || typeof header === "boolean") return;
+	if (isToken(header)) return;
+	throw invalidConfigError(`${options.prefix} Session "sessionHeader" must be true, false or a header name (got ${quoteTokenValue(header)}).`);
+}
+function sessionHeaderName(sessionName, configured) {
+	if (typeof configured === "string") return configured.toLowerCase();
+	return `x-${sessionName.replace(/^__(?:host|secure)-/i, "").toLowerCase()}-session`;
+}
+function headerToken(value) {
+	if (typeof value !== "string") return void 0;
+	const words = value.trim().split(/\s+/);
+	const [first = "", second] = words;
+	if (/^bearer$/i.test(first)) return words.length === 2 ? second : void 0;
+	return words.length === 1 && first ? first : void 0;
+}
+function presentedHeader(driver, event, options) {
+	const { name, sessionHeader } = options;
+	if (!readsHeader(options)) return void 0;
+	const header = sessionHeaderName(name, sessionHeader);
+	const value = driver.header(event, header);
+	if (typeof value !== "string") return void 0;
+	const token = headerToken(value);
+	if (token) return { token };
+	return {
+		token: void 0,
+		malformed: { header }
+	};
+}
+function headerTransport(options, header) {
+	return {
+		source: "header",
+		read: readsHeader(options) ? () => header?.token : void 0,
+		malformed: header?.malformed,
+		readonly: false,
+		writable: () => true
+	};
+}
+function readsHeader(options) {
+	return options.sessionHeader !== void 0 && options.sessionHeader !== false;
+}
+function cookieToken(jar, name) {
+	const written = jar.written ? readChunked({ read: (key) => jar.written?.(key) }, name) : void 0;
+	if (written === "") return void 0;
+	return (written ?? readChunked(jar, name)) || void 0;
+}
+function responseStore(jar) {
+	const write = jar.write?.bind(jar);
+	if (!write) return void 0;
+	return {
+		read: (name) => jar.written?.(name) ?? jar.read(name),
+		write
+	};
+}
+const kSessionNames = Symbol("unjwt_session_names");
+const kHeldTokens = Symbol("unjwt_session_held_tokens");
+function assertSessionConfig(config, options) {
+	const { name, prefix, defaultCookie = DEFAULT_SESSION_COOKIE } = options;
+	assertSessionName(name, { prefix });
+	assertSessionHeader(config.sessionHeader, { prefix });
+	if (config.cookie !== false) assertCookiePrefix(name, {
+		...defaultCookie,
+		...config.cookie
+	}, { prefix });
+	assertRolling(config, { prefix });
+}
+function sessionTransportOptions(config, options) {
+	const { name, defaultCookie = DEFAULT_SESSION_COOKIE } = options;
+	const { sessionHeader } = config;
+	if (config.cookie === false) return {
+		name,
+		sessionHeader,
+		cookie: false
+	};
+	const { chunkMaxLength, ...configured } = config.cookie || {};
+	return {
+		name,
+		sessionHeader,
+		cookie: {
+			attrs: {
+				...defaultCookie,
+				...configured
+			},
+			chunkMaxLength
+		}
+	};
+}
+function claimSessionName(state, options) {
+	const { name, family, prefix } = options;
+	const holder = state;
+	const registry = holder[kSessionNames] ||= /* @__PURE__ */ new Map();
+	const held = registry.get(name);
+	if (held === void 0) {
+		registry.set(name, family);
+		return;
+	}
+	if (held === family) return;
+	throw invalidConfigError(`${prefix} Session name "${name}" is already used by a ${held.toUpperCase()} session on this request.`);
+}
+function bindSession(event, options) {
+	const { config, name, driver, codec, keys, actions } = options;
+	const record = driver.state(event);
+	claimSessionName(record, {
+		name,
+		family: codec.family,
+		prefix: driver.prefix
+	});
+	const slot = `${codec.family}:${name}`;
+	return {
+		event,
+		config,
+		driver,
+		codec,
+		keys,
+		actions,
+		name,
+		args: { event },
+		store: recordSlotStore(record, slot),
+		held: heldTokenSlot(record, slot),
+		transport: resolveSessionTransport(driver, event, sessionTransportOptions(config, { name }))
+	};
+}
+function sessionToken(binding) {
+	const { transport } = binding;
+	assertSessionTokenSource(transport, { prefix: binding.driver.prefix });
+	const session = storedSession(binding.store);
+	return session ? session.token : transport.read();
+}
+function transportToken(binding) {
+	const { transport } = binding;
+	assertSessionTokenSource(transport, { prefix: binding.driver.prefix });
+	const held = binding.held.get();
+	return held ? held.token : transport.read();
+}
+function recordSlotStore(record, slot) {
+	return {
+		get: () => record[slot],
+		set: (state) => {
+			record[slot] = state;
+		}
+	};
+}
+function heldTokenSlot(record, slot) {
+	const holder = record;
+	const held = holder[kHeldTokens] ||= /* @__PURE__ */ new Map();
+	return {
+		get: () => held.has(slot) ? { token: held.get(slot) } : void 0,
+		set: (token) => {
+			held.set(slot, token);
+		}
+	};
+}
+async function loadSession(binding) {
+	const { config, codec, keys, store, args, transport } = binding;
+	await keys.assertKeys();
+	const open = keys.opener(args);
+	assertSessionTokenSource(transport, { prefix: binding.driver.prefix });
+	const existing = storedSession(store);
+	if (existing) {
+		const session = existing[kSessionPending] ? await existing[kSessionPending] : existing;
+		if (session.token !== void 0 && session.expiresAt !== void 0 && session.expiresAt <= codec.now(config)) {
+			transport.drop?.();
+			const error = expiredSessionError({
+				id: session.id,
+				createdAt: session.createdAt,
+				expiresAt: session.expiresAt
+			});
+			const freshSession = emptySession(binding);
+			freshSession.error = error;
+			store.set(freshSession);
+			await fireExpire(binding, {
+				session: {
+					id: session.id,
+					createdAt: session.createdAt,
+					expiresAt: session.expiresAt,
+					token: session.token
+				},
+				error
+			});
+			return freshSession;
+		}
+		return session;
+	}
+	const session = emptySession(binding);
+	store.set(session);
+	if (transport.malformed) {
+		const error = malformedHeaderError(transport.malformed.header, { prefix: binding.driver.prefix });
+		session.error = error;
+		await fireError(binding, error);
+		return session;
+	}
+	const token = transport.read();
+	if (!token) return session;
+	binding.held.set(token);
+	session.token = token;
+	const pending = open(token).then((opened) => {
+		Object.assign(session, opened);
+		return { failure: void 0 };
+	}, (error) => {
+		session.token = void 0;
+		return { failure: { error } };
+	}).then((outcome) => {
+		delete session[kSessionPending];
+		return outcome;
+	});
+	session[kSessionPending] = pending.then(() => session);
+	const { failure } = await pending;
+	if (failure) {
+		if (isJWTError(failure.error)) session.error = failure.error;
+		if (isJWTError(failure.error, "ERR_JWT_EXPIRED")) {
+			const { jti, iat, exp } = failure.error.cause;
+			transport.drop?.();
+			await fireExpire(binding, {
+				session: {
+					id: jti,
+					createdAt: iat ? iat * 1e3 : void 0,
+					expiresAt: exp ? exp * 1e3 : void 0,
+					token
+				},
+				error: failure.error
+			});
+		} else {
+			if (isJWTError(failure.error, "ERR_SESSION_TOKEN_INVALID")) transport.drop?.();
+			await fireError(binding, failure.error);
+		}
+		return session;
+	}
+	try {
+		await fireRead(binding, session);
+	} catch (error_) {
+		store.set(emptySession(binding));
+		throw error_;
+	}
+	await rollSession(binding, session);
+	return session;
+}
+async function fireRead(binding, session) {
+	if (session.id === void 0 || session.token === void 0) return;
+	await binding.config.hooks?.onRead?.({
+		session: binding.actions.manager(binding),
+		...binding.args,
+		config: binding.config
+	});
+}
+async function rollSession(binding, session) {
+	const { config, codec, transport, store } = binding;
+	const { rolling } = config;
+	if (rolling === void 0 || transport.source !== "cookie" || store.get() !== session) return;
+	if (session.token === void 0 || session.expiresAt === void 0) return;
+	if (rolling !== true) {
+		if (codec.now(config) - session.createdAt < computeDurationInSeconds(rolling) * 1e3) return;
+	}
+	if (transport.readonly || !transport.writable()) return;
+	await binding.actions.roll(binding);
+}
+async function fireError(binding, error) {
+	await binding.config.hooks?.onError?.({
+		session: binding.actions.manager(binding),
+		...binding.args,
+		error,
+		config: binding.config
+	});
+}
+async function fireExpire(binding, expired) {
+	await binding.config.hooks?.onExpire?.({
+		session: {
+			...expired.session,
+			source: binding.transport.source
+		},
+		...binding.args,
+		error: expired.error,
+		config: binding.config
+	});
+}
+async function issueSession(binding, update, options, trigger = "update") {
+	const { config, keys, driver, store, args, transport } = binding;
+	assertSessionWritable(transport, {
+		operation: "update",
+		prefix: driver.prefix
+	});
+	const session = storedSession(store) || await loadSession(binding);
+	const oldSession = snapshotSession(session);
+	const resolved = typeof update === "function" ? update(session.data) : update;
+	if (resolved) Object.assign(session.data, sanitizeSessionUpdate(resolved, { prefix: driver.prefix }));
+	for (const claim of RESERVED_CLAIMS) delete session.data[claim];
+	const maxAge = options?.maxAge ?? config.maxAge;
+	const createdAt = sessionInstant(binding);
+	const id = mintSessionId(config);
+	Object.assign(session, {
+		id,
+		createdAt,
+		expiresAt: resolveExpiresAt(createdAt, { maxAge })
+	});
+	let issued;
+	try {
+		await keys.assertKeys();
+		const token = await keys.issue(session);
+		transport.write?.(token, { expiresAt: session.expiresAt });
+		binding.held.set(token);
+		issued = Object.assign(session, {
+			id,
+			token,
+			error: void 0
+		});
+	} catch (error_) {
+		Object.assign(session, {
+			id: oldSession.id,
+			createdAt: oldSession.createdAt,
+			expiresAt: oldSession.expiresAt,
+			data: oldSession.data
+		});
+		session.token = oldSession.token;
+		await config.hooks?.onError?.({
+			session: binding.actions.manager(binding),
+			...args,
+			error: error_,
+			config
+		});
+		throw error_;
+	}
+	await config.hooks?.onUpdate?.({
+		session: binding.actions.manager(binding),
+		oldSession,
+		trigger,
+		...args,
+		config
+	});
+	return issued;
+}
+async function dropSession(binding) {
+	const { config, driver, store, args, transport } = binding;
+	assertSessionTokenSource(transport, { prefix: driver.prefix });
+	assertSessionWritable(transport, {
+		operation: "clear",
+		prefix: driver.prefix
+	});
+	let session = storedSession(store);
+	if (session && session[kSessionPending]) session = await session[kSessionPending];
+	const oldSession = session && (session.id !== void 0 || session.token !== void 0 || session.error !== void 0) ? snapshotSession(session) : void 0;
+	store.set(emptySession(binding));
+	binding.held.set(void 0);
+	transport.drop?.();
+	await config.hooks?.onClear?.({
+		oldSession,
+		...args,
+		config
+	});
+}
+function sessionManager(binding) {
+	const { store } = binding;
+	const state = () => storedSession(store);
+	const manager = {
+		get id() {
+			return state()?.id;
+		},
+		get createdAt() {
+			return state()?.createdAt ?? Date.now();
+		},
+		get expiresAt() {
+			return (state() ?? blankSession()).expiresAt;
+		},
+		get data() {
+			return (state() ?? blankSession()).data;
+		},
+		get token() {
+			return sessionToken(binding);
+		},
+		get source() {
+			return binding.transport.source;
+		},
+		get error() {
+			return state()?.error;
+		},
+		update: async (update, options) => {
+			await issueSession(binding, update, options);
+			return manager;
+		},
+		clear: async () => {
+			await dropSession(binding);
+			return manager;
+		}
+	};
+	return manager;
+}
+function sessionActions() {
+	return {
+		manager: (binding) => sessionManager(binding),
+		roll: async (binding) => {
+			await issueSession(binding, void 0, void 0, "rolling");
+		}
+	};
+}
+function snapshotSession(session) {
+	return {
+		...session,
+		data: safeJsonParse(JSON.stringify(session.data))
+	};
+}
+function defineSession(config, options) {
+	const { driver, codec } = options;
+	const name = config.name || codec.defaultName;
+	assertSessionConfig(config, {
+		name,
+		prefix: driver.prefix
+	});
+	const keys = codec.keys(config);
+	const actions = sessionActions();
+	const bind = (event) => bindSession(event, {
+		config,
+		name,
+		driver,
+		codec,
+		keys,
+		actions
+	});
+	return {
+		use: async (event) => {
+			const binding = bind(event);
+			await loadSession(binding);
+			return sessionManager(binding);
+		},
+		token: (event) => transportToken(bind(event)),
+		issue: async (data, issueOptions) => {
+			await keys.assertKeys();
+			const createdAt = sessionInstant({
+				codec,
+				config
+			});
+			return keys.issue({
+				id: mintSessionId(config),
+				createdAt,
+				expiresAt: resolveExpiresAt(createdAt, { maxAge: issueOptions?.maxAge ?? config.maxAge }),
+				data: sanitizeSessionUpdate(data ?? {}, { prefix: driver.prefix }),
+				token: void 0,
+				source: "token",
+				error: void 0
+			});
+		},
+		open: (token) => openSessionToken(keys, {
+			token,
+			args: {}
+		})
+	};
+}
+function webCookieJar(request, response) {
+	let cookies;
+	const jar = { read: (name) => (cookies ||= parseCookie(request.get("cookie") ?? ""))[name] };
+	if (response) {
+		const { headers, errHeaders } = response;
+		jar.written = (name) => setCookieValues(headers.getSetCookie())[name];
+		jar.write = (name, value, attrs) => {
+			setCookie(headers, {
+				...attrs,
+				name,
+				value
+			});
+			if (errHeaders) mirrorSetCookie(name, {
+				from: headers,
+				to: errHeaders
+			});
+		};
+	}
+	return jar;
+}
+function parseCookie(header) {
+	return parse(header);
+}
+function serializeCookie(name, value, attrs) {
+	return serialize({
+		path: "/",
+		...attrs,
+		name,
+		value
+	});
+}
+function setCookie(headers, cookie) {
+	const { name, value, ...attrs } = cookie;
+	const line = serializeCookie(name, value, attrs);
+	const key = cookieKey(cookie);
+	const kept = headers.getSetCookie().filter((existing) => {
+		const parsed = parseSetCookie(existing);
+		return parsed ? cookieKey(parsed) !== key : setCookieName(existing) !== name;
+	});
+	headers.delete("set-cookie");
+	for (const existing of kept) headers.append("set-cookie", existing);
+	headers.append("set-cookie", line);
+}
+function cookieKey(cookie) {
+	const domain = (cookie.domain || "").replace(/^\./, "").toLowerCase();
+	return [
+		cookie.name,
+		domain,
+		cookie.path || "/",
+		cookie.partitioned ? "1" : "0"
+	].join(";");
+}
+const requestStates = /* @__PURE__ */ new WeakMap();
+function webSessionDriver(options) {
+	const prefix = options?.prefix ?? "[unjwt/session]";
+	return {
+		prefix,
+		state: (event) => {
+			if (isHanded(event, prefix)) return sessionsOf(event);
+			if (event.context) return contextState(event.context);
+			return sessionsOf(event.req ? webRequest(event.req, prefix) : event);
+		},
+		header: (event, name) => isHanded(event, prefix) ? void 0 : requestHeaders(event, prefix).get(name),
+		cookies: (event) => isHanded(event, prefix) ? { read: () => void 0 } : webCookieJar(requestHeaders(event, prefix), event.res),
+		handed: (event) => isHanded(event, prefix) ? { token: event.token } : void 0
+	};
+}
+const defaultWebSessionDriver = /* @__PURE__ */ webSessionDriver();
+function isHanded(event, prefix) {
 	if ("req" in event || "headers" in event) return false;
 	if ("token" in event) return true;
-	throw invalidConfigError(`${PREFIX} use() got neither a request event nor a token.`);
+	throw invalidConfigError(`${prefix} use() got neither a request event nor a token.`);
 }
-function requestHeaders(event) {
-	if (event.req) return webRequest(event.req).headers;
+function requestHeaders(event, prefix) {
+	if (event.req) return webRequest(event.req, prefix).headers;
 	if (event.headers) return event.headers;
-	throw invalidConfigError(`${PREFIX} use() got a request event with neither "req" nor "headers".`);
+	throw invalidConfigError(`${prefix} use() got a request event with neither "req" nor "headers".`);
 }
-function webRequest(req) {
+function webRequest(req, prefix) {
 	const headers = req.headers;
 	if (typeof headers === "object" && headers !== null && "get" in headers) return req;
-	throw invalidConfigError(`${PREFIX} use() got an event whose "req" is not a web Request.`);
+	throw invalidConfigError(`${prefix} use() got an event whose "req" is not a web Request.`);
 }
-function contextSessions(context) {
-	const existing = context.sessions;
+function contextState(context) {
+	const existing = context.unjwt;
 	if (typeof existing === "object" && existing !== null) return existing;
 	const created = Object.create(null);
-	context.sessions = created;
+	context.unjwt = created;
 	return created;
 }
-function sessionsOf(key) {
-	const existing = SESSIONS.get(key);
+function sessionsOf(request) {
+	const existing = requestStates.get(request);
 	if (existing) return existing;
 	const created = Object.create(null);
-	SESSIONS.set(key, created);
+	requestStates.set(request, created);
 	return created;
 }
 function defineJWSSession(config, options) {
-	const driver = options?.driver ?? webSessionDriver;
+	const driver = options?.driver ?? defaultWebSessionDriver;
 	return defineSession(config, {
 		driver,
-		hookArgs: (event) => ({ event }),
 		codec: createJWSCodec({
 			prefix: driver.prefix,
-			defaultName: "unjwt-jws"
+			defaultName: "__Host-unjwt-jws"
 		})
 	});
 }
+const JWE_KEY_RULES = {
+	own: (key) => isJWK(key) && key.alg ? inferJWEAllowedAlgorithms(key) ?? [] : void 0,
+	carried: (key) => {
+		if (isCryptoKey(key)) {
+			const name = key.algorithm.name;
+			if (name === "PBKDF2") return PBES2_ALGORITHMS;
+			const wraps = inferJWEAllowedAlgorithms(key) ?? [];
+			return name === "AES-GCM" && wraps.length > 0 ? [...wraps, "dir"] : wraps;
+		}
+		if (!isSymmetricJWK(key)) return [];
+		const algs = aesWraps(octBits(key));
+		return directEncryptions(key).length > 0 ? [...algs, "dir"] : algs;
+	},
+	pinPath: "jwe.encryptOptions.alg",
+	hint: "\"jwe.encryptOptions.alg\" and \"enc\"",
+	listPath: "jwe.decryptOptions.algorithms",
+	limitPath: "jwe.decryptOptions.limits.keyCandidates"
+};
+function resolveSessionKeys(key, options) {
+	const { alg: pin, enc, prefix } = options;
+	assertKeyMaterial(key, { prefix });
+	const entries = isJWKSet(key) ? sessionKeySetEntries(key.keys, {
+		...options,
+		pin,
+		rules: JWE_KEY_RULES
+	}) : [{
+		key: sessionSecret(key, prefix),
+		subject: "The session key",
+		pin
+	}];
+	assertIssuingKey(entries[0], {
+		enc,
+		prefix
+	});
+	const { all } = servedAlgorithms(entries, {
+		...options,
+		rules: JWE_KEY_RULES
+	});
+	return {
+		issueKey: entries[0].key,
+		key,
+		algorithms: all
+	};
+}
+function assertIssuingKey(entry, options) {
+	const { enc, prefix } = options;
+	const { key, subject, pin } = entry;
+	assertPinnedKey(entry, {
+		rules: JWE_KEY_RULES,
+		pinned: Boolean(pin && enc),
+		prefix
+	});
+	if ((pin ?? JWE_KEY_RULES.own(key)?.[0]) !== "dir" || !enc) return;
+	const encs = directEncryptions(key);
+	if (encs.includes(enc)) return;
+	throw invalidKeyError(`${prefix} ${subject} serves "dir" with ${encs.join(", ") || "no content encryption"}, not the "${enc}" that "jwe.encryptOptions.enc" pins.`, key);
+}
+function directEncryptions(key) {
+	if (isJWK(key) && typeof key.alg === "string" && isContentEncryptionAlgorithm(key.alg)) return [key.alg];
+	if (isCryptoKey(key)) {
+		const bits = lengthOf(key.algorithm) ?? 0;
+		return key.algorithm.name === "AES-GCM" ? GCM_ENCRYPTIONS.filter((enc) => enc === `A${bits}GCM`) : [];
+	}
+	if (!isSymmetricJWK(key)) return [];
+	const bits = octBits(key);
+	return [...GCM_ENCRYPTIONS, ...CBC_ENCRYPTIONS].filter((enc) => encryptionBits(enc) === bits);
+}
+function sessionSecret(key, prefix) {
+	if (isOctJWK(key)) return key;
+	if (isCryptoKey(key) && key.type === "secret") return key;
+	throw invalidKeyError((isCryptoKey(key) ? key.type !== "secret" : isAsymmetricJWK(key) || isKeyPair(key)) ? `${prefix} Invalid JWE session key: an asymmetric key seals with its public half, so anyone holding that half could mint sessions. Use an "oct" JWK, or defineJWSSession for a key pair.` : `${prefix} Invalid JWE session key: expected an "oct" JWK, a JWK Set of them or a secret CryptoKey.`, key);
+}
+function isOctJWK(key) {
+	return isSymmetricJWK(key);
+}
+const GCM_ENCRYPTIONS = [
+	"A128GCM",
+	"A192GCM",
+	"A256GCM"
+];
+const CBC_ENCRYPTIONS = [
+	"A128CBC-HS256",
+	"A192CBC-HS384",
+	"A256CBC-HS512"
+];
+function aesWraps(bits) {
+	switch (bits) {
+		case 128: return ["A128KW", "A128GCMKW"];
+		case 192: return ["A192KW", "A192GCMKW"];
+		case 256: return ["A256KW", "A256GCMKW"];
+		default: return [];
+	}
+}
+function encryptionBits(enc) {
+	const bits = Number(enc.slice(1, 4));
+	return enc.includes("CBC") ? bits * 2 : bits;
+}
+function createJWECodec(options) {
+	const { prefix, defaultName } = options;
+	return createSessionCodec({
+		family: "jwe",
+		prefix,
+		defaultName,
+		issueOptions: (config) => config.jwe?.encryptOptions,
+		openOptions: (config) => config.jwe?.decryptOptions,
+		resolveKeys: (config) => resolveSessionKeys(config.key, {
+			alg: config.jwe?.encryptOptions?.alg,
+			enc: config.jwe?.encryptOptions?.enc,
+			listed: config.jwe?.decryptOptions?.algorithms,
+			limits: config.jwe?.decryptOptions?.limits,
+			lookup: typeof config.hooks?.onKeyLookup === "function",
+			prefix
+		}),
+		lookup: (config) => config.hooks?.onKeyLookup,
+		issue: (config, payload, key) => encrypt(payload, key, sessionIssueOptions(config.jwe?.encryptOptions)),
+		open: async (config, sealed, key, overrides) => {
+			const { payload } = await decrypt(sealed, key, {
+				...config.jwe?.decryptOptions,
+				maxIterations: sessionMaxIterations(config),
+				...overrides
+			});
+			return payload;
+		}
+	});
+}
+function sessionMaxIterations(config) {
+	const configured = config.jwe?.decryptOptions?.maxIterations;
+	if (configured !== void 0) return configured;
+	const issuing = isJWKSet(config.key) ? config.key.keys[0] : config.key;
+	const alg = config.jwe?.encryptOptions?.alg ?? (isJWK(issuing) ? issuing.alg : void 0);
+	return typeof alg === "string" && alg.startsWith("PBES2") ? config.jwe?.encryptOptions?.p2c ?? 6e5 : void 0;
+}
 function defineJWESession(config, options) {
-	const driver = options?.driver ?? webSessionDriver;
+	const driver = options?.driver ?? defaultWebSessionDriver;
 	return defineSession(config, {
 		driver,
-		hookArgs: (event) => ({ event }),
 		codec: createJWECodec({
 			prefix: driver.prefix,
-			defaultName: "unjwt-jwe"
+			defaultName: "__Host-unjwt-jwe"
 		})
 	});
 }
 function defineSessionDriver(driver) {
 	return driver;
 }
-export { defineJWESession, defineJWSSession, defineSessionDriver, deriveJWKFromPassword, exportPEM, generateJWK, importPEM, thumbprint, toPublicJWK };
+export { DEFAULT_SESSION_COOKIE, assertSessionConfig, assertSessionHeader, assertSessionTokenSource, assertSessionWritable, claimSessionName, defineJWESession, defineJWSSession, defineSessionDriver, deriveJWKFromPassword, exportPEM, generateJWK, importPEM, parseCookie, resolveSessionTransport, serializeCookie, sessionTransportOptions, thumbprint, toPublicJWK, webCookieJar, webSessionDriver };