unjwt 0.8.4 → 0.8.5

package/dist/_chunks/{_codec-jwe.d.mts → codec-jwe.d.mts}

@@ -1,3 +1,4 @@
+import "./error.mjs";
 import { ExpiresIn, JWEAsymmetricPrivateJWK, JWEAsymmetricPublicJWK, JWEDecryptJWK, JWEDecryptOptions, JWEEncryptJWK, JWEEncryptOptions, JWEHeaderParameters, JWKSet, JWK_HMAC, JWK_oct, JWSAsymmetricPrivateJWK, JWSAsymmetricPublicJWK, JWSHeaderParameters, JWSSignOptions, JWSVerifyJWK, JWSVerifyOptions, JWTClaims, StrictOmit } from "./index.mjs";
 interface ExpirableCookieAttributes {
   expires?: Date;
@@ -14,7 +15,7 @@ export type SessionUpdate<T extends SessionRecord = SessionClaims> = Partial<Ses
 export interface SessionManager<T extends SessionRecord = SessionClaims, ConfigMaxAge extends ExpiresIn | undefined = ExpiresIn | undefined> {
   readonly id: string | undefined;
   readonly createdAt: number;
-  /** Expiry in ms — always a number when the session has a `maxAge`. */
+  /** Expiry in ms: `exp`, or `iat + maxAge` when sooner; always a number when the session has a `maxAge`. */
   readonly expiresAt: ConfigMaxAge extends ExpiresIn ? number : number | undefined;
   readonly data: SessionData<T>;
   readonly token: string | undefined;
@@ -28,7 +29,7 @@ export interface SessionManager<T extends SessionRecord = SessionClaims, ConfigM
 }
 /** The config members every session shares, whether it signs or seals its token. */
 interface SessionBaseConfig<MaxAge extends ExpiresIn | undefined = ExpiresIn | undefined> {
-  /** Sets `exp = iat + maxAge`, requires `exp` on incoming tokens, drives cookie expiry; unset never expires. */
+  /** Sets `exp = iat + maxAge`, requires `exp` on incoming tokens and ends them at `iat + maxAge` at the latest, drives cookie expiry; unset never expires. */
   maxAge?: MaxAge;
   /**
    * Reissue the session when it is read, needs `maxAge`.
@@ -49,6 +50,7 @@ interface SessionBaseConfig<MaxAge extends ExpiresIn | undefined = ExpiresIn | u
   name?: string;
   /**
    * Header carrying a bare or `Bearer` token: a header name, `true` for `x-<name>-session` (cookie prefix stripped), or `false` for none.
+   * A request that carries it is read from it and never from the cookie, and writes no cookie back; any other value is a token failure (`onError`).
    * Left unset, a session with cookies still reads `x-<name>-session`, and so does one with `cookie: false`.
    */
   sessionHeader?: boolean | string;
@@ -68,7 +70,7 @@ interface SessionHooks<TSession, TManager, TArgs extends Record<string, unknown>
     };
     config: TConfig;
   }) => void | Promise<void>;
-  /** Fires after a token is issued and its cookie written, by `update()` or by `rolling`; a throw rejects without rollback. */
+  /** Fires after a token is issued and, on a cookie session, its cookie written, by `update()` or by `rolling`; a throw rejects without rollback. */
   onUpdate?: (args: TArgs & {
     session: TManager & {
       id: string;
@@ -104,7 +106,7 @@ interface SessionHooks<TSession, TManager, TArgs extends Record<string, unknown>
 }
 /** Per-issue overrides for a single `update()` call. */
 export interface SessionIssueOptions {
-  /** Lifetime for this issue only, overriding the config's `maxAge`. */
+  /** Lifetime for this issue only, overriding the config's `maxAge`; a read under that `maxAge` still ends the session at `iat + maxAge`. */
   maxAge?: ExpiresIn;
 }
 /** In-request session state, mirroring the claims of the underlying token. */
@@ -113,7 +115,7 @@ export interface SessionState<T extends SessionRecord, MaxAge extends ExpiresIn
   id: string | undefined;
   /** In ms; mirrors the JWT `iat` claim (seconds). */
   createdAt: number;
-  /** In ms; mirrors the JWT `exp` claim (seconds). */
+  /** In ms; mirrors the JWT `exp` claim (seconds), or `iat + maxAge` when sooner. */
   expiresAt: MaxAge extends ExpiresIn ? number : number | undefined;
   data: SessionData<T>;
   token: string | undefined;
@@ -127,7 +129,7 @@ export type OpenedSessionState<T extends SessionRecord, MaxAge extends ExpiresIn
 export interface SessionDefinition<T extends SessionRecord = SessionClaims, MaxAge extends ExpiresIn | undefined = ExpiresIn | undefined, TEvent = unknown> {
   /** Reads the request's session once and returns its manager; later calls on the same request share that state. */
   use: (event: TEvent) => Promise<SessionManager<T, MaxAge>>;
-  /** The token the request carries (this response's own write first), unopened. */
+  /** The session's token once `use()` read or wrote it, else the one the request carries (the session header before the cookie), unopened. */
   token: (event: TEvent) => string | undefined;
   /** Mints a token for `data` with a fresh `jti` and `iat`, and `exp` from `maxAge` (`options.maxAge` overrides it); reads and writes nothing. */
   issue: (data?: Partial<SessionData<T>>, options?: SessionIssueOptions) => Promise<string>;
@@ -135,9 +137,13 @@ export interface SessionDefinition<T extends SessionRecord = SessionClaims, MaxA
   open: (token: string) => Promise<OpenedSessionState<T, MaxAge>>;
 }
 interface SessionRequestBase {
-  /** The response being prepared; without it the session is read-only. */
+  /**
+   * The response being prepared; without it the session is read-only.
+   * With `errHeaders` too (h3 v2, which sends only those for a thrown handler), every cookie write lands in both.
+   */
   readonly res?: {
     readonly headers: Headers;
+    readonly errHeaders?: Headers;
   };
   /** Per-request state shared with the framework, where `sessions` is kept; without it state is keyed on `req`, else on this object. */
   readonly context?: Record<string, unknown>;
@@ -213,10 +219,35 @@ export interface JWSSessionHooks<TSession, TManager, TArgs extends Record<string
     config: TConfig;
   }) => JWKSet | JWSVerifyJWK | Promise<JWKSet | JWSVerifyJWK>;
 }
-/** Symmetric JWK, `CryptoKey` (requires pinned `alg` and `enc`), or a pair: public seals, private unseals. */
+/**
+ * A symmetric `oct` JWK, or a `CryptoKey` (requires pinned `alg` and `enc`): the one key seals and unseals.
+ *
+ * The `{ privateKey, publicKey? }` pair members are deprecated: a pair seals with its public half,
+ * so anyone holding the public key can mint a session the server accepts. Use an `oct` JWK, or
+ * `defineJWSSession` for a key pair.
+ */
 type JWESessionKey = CryptoKey | JWEEncryptJWK | {
-  privateKey: JWEAsymmetricPrivateJWK | CryptoKey;
+  /**
+   * Unseals; a private JWK alone seals with its own public half.
+   * @deprecated A pair seals with its public half, so anyone holding the public key can mint a session the server accepts. Use an `oct` JWK, or `defineJWSSession` for a key pair.
+   */
+  privateKey: JWEAsymmetricPrivateJWK;
+  /**
+   * Seals.
+   * @deprecated A pair seals with its public half, so anyone holding the public key can mint a session the server accepts. Use an `oct` JWK, or `defineJWSSession` for a key pair.
+   */
   publicKey?: JWEAsymmetricPublicJWK | CryptoKey;
+} | {
+  /**
+   * Unseals; a private `CryptoKey` has no public half to derive, so it comes with one.
+   * @deprecated A pair seals with its public half, so anyone holding the public key can mint a session the server accepts. Use an `oct` JWK, or `defineJWSSession` for a key pair.
+   */
+  privateKey: CryptoKey;
+  /**
+   * Seals.
+   * @deprecated A pair seals with its public half, so anyone holding the public key can mint a session the server accepts. Use an `oct` JWK, or `defineJWSSession` for a key pair.
+   */
+  publicKey: JWEAsymmetricPublicJWK | CryptoKey;
 };
 /** JWE decrypt overrides, minus the options the adapter owns. */
 export type SessionDecryptOptions = StrictOmit<JWEDecryptOptions, "algorithms" | "encryptionAlgorithms" | "typ" | "maxTokenAge" | "validateClaims" | "forceUint8Array" | "payload">;

package/dist/_chunks/{_codec-jws.mjs → codec-jws.mjs}

@@ -1,8 +1,10 @@
-import { sanitizeObjectCopy } from "./libs/unsecure.mjs";
-import { JWTError, computeDurationInSeconds, expiredClaimMessage, isCryptoKey, isJWK, isJWKSet, isJWTError, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK } from "./_jwt-internal.mjs";
-import { importKey, quoteTokenValue } from "./_import-key.mjs";
+import { safeJsonParse } from "./libs/unsecure.mjs";
+import { JWTError, isJWTError } from "../error.mjs";
+import { computeDurationInSeconds, expiredClaimMessage, isCryptoKey, isJWK, isJWKSet, isPlainObject, isPrivateJWK, isPublicJWK, isSymmetricJWK, quoteTokenValue } from "./jwt.mjs";
+import { importKey } from "./algorithms.mjs";
 import { sign, verify } from "./jws.mjs";
 import { decrypt, encrypt } from "./jwe.mjs";
+import { toPublicJWK } from "./export.mjs";
 const RESERVED_CLAIMS = [
 	"jti",
 	"iat",
@@ -29,10 +31,12 @@ function readOnlyEventError(message) {
 	return new JWTError(message, "ERR_SESSION_READONLY_EVENT");
 }
 function expiredSessionError(options) {
-	const { id, expiresAt } = 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
 	});
 }
@@ -131,12 +135,17 @@ function createSessionCodec(spec) {
 	const now = (config) => spec.issueOptions(config)?.currentDate?.getTime() ?? Date.now();
 	const openWith = async (config, token, key) => {
 		const payload = await spec.open(config, token, key).catch((error) => rethrowAsInvalidToken(error, { prefix }));
-		assertNotFromTheFuture(payload, {
+		const clock = {
 			now: now(config),
-			clockTolerance: spec.openOptions(config)?.clockTolerance,
+			clockTolerance: spec.openOptions(config)?.clockTolerance
+		};
+		assertNotFromTheFuture(payload, {
+			...clock,
 			prefix
 		});
-		return openedSession(payload);
+		const opened = openedSession(payload, { maxAge: config.maxAge });
+		assertNotPastMaxAge(opened, clock);
+		return opened;
 	};
 	const assertOpenKey = async (config) => {
 		if (spec.lookup(config, {})) return;
@@ -218,19 +227,33 @@ function sessionPayload(state) {
 	return payload;
 }
 function assertNotFromTheFuture(payload, options) {
-	const tolerance = options.clockTolerance === void 0 ? 0 : computeDurationInSeconds(options.clockTolerance);
-	if (payload.iat > Math.floor(options.now / 1e3) + tolerance) throw invalidTokenError(`${options.prefix} Invalid session token: "iat" is in the future (${(/* @__PURE__ */ new Date(payload.iat * 1e3)).toISOString()}).`);
+	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
+	});
+}
+function toleranceSeconds(clockTolerance) {
+	return clockTolerance === void 0 ? 0 : computeDurationInSeconds(clockTolerance);
 }
-function openedSession(payload) {
+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: payload.iat * 1e3,
-		expiresAt: payload.exp ? payload.exp * 1e3 : void 0,
+		createdAt,
+		expiresAt: exp === void 0 || bound === void 0 ? exp ?? bound : Math.min(exp, bound),
 		data
 	};
 }
@@ -290,10 +313,7 @@ function getEncryptKey(config, prefix) {
 	assertKeyMaterial(key, { prefix });
 	let resolved;
 	if (isCryptoKey(key) || isSymmetricJWK(key)) resolved = key;
-	else if (isKeyPair(key)) {
-		assertJWEKeyPair(key, prefix);
-		resolved = key.publicKey;
-	}
+	else if (isKeyPair(key)) resolved = jweKeyPair(key, prefix).publicKey;
 	if (!resolved) throw invalidKeyError(`${prefix} Invalid JWE key, expected a JWK or a CryptoKey.`, key);
 	assertPinnedAlgEnc(resolved, config, prefix);
 	return resolved;
@@ -303,21 +323,27 @@ function getDecryptKey(config, prefix) {
 	assertKeyMaterial(key, { prefix });
 	let resolved;
 	if (isCryptoKey(key) || isSymmetricJWK(key)) resolved = key;
-	else if (isKeyPair(key)) {
-		assertJWEKeyPair(key, prefix);
-		resolved = key.privateKey;
-	}
+	else if (isKeyPair(key)) resolved = jweKeyPair(key, prefix).privateKey;
 	if (!resolved) throw invalidKeyError(`${prefix} Invalid JWE key, expected a JWK, a private JWK or a CryptoKey.`, key);
 	assertPinnedAlgEnc(resolved, config, prefix);
 	return resolved;
 }
-function assertJWEKeyPair(key, prefix) {
-	assertKeyPair(key, {
+function jweKeyPair(key, prefix) {
+	const pair = {
+		privateKey: key.privateKey,
+		publicKey: key.publicKey ?? derivedPublicHalf(key.privateKey, prefix)
+	};
+	assertKeyPair(pair, {
 		prefix,
 		family: "JWE",
 		isPublic: (half) => isCryptoKey(half) || isPublicJWK(half),
 		publicHalf: "a public JWK or a CryptoKey"
 	});
+	return pair;
+}
+function derivedPublicHalf(privateKey, prefix) {
+	if (isPrivateJWK(privateKey)) return toPublicJWK(privateKey);
+	throw invalidKeyError(`${prefix} Invalid JWE key: a CryptoKey "privateKey" needs its "publicKey".`, privateKey);
 }
 function assertPinnedAlgEnc(key, config, prefix) {
 	const { alg, enc } = config.jwe?.encryptOptions ?? {};
@@ -327,6 +353,43 @@ function assertPinnedAlgEnc(key, config, prefix) {
 		hint: "\"jwe.encryptOptions.alg\" and \"enc\""
 	});
 }
+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
+	});
+}
+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(codec, config, options) {
+	return codec.open(config, options.token, options.args).then(typedOpened);
+}
+function typedSession(state) {
+	return state;
+}
+function typedOpened(opened) {
+	return opened;
+}
 const CHUNK_MARKER = "__chunked__";
 const DEFAULT_CHUNK_MAX_LENGTH = 4e3;
 function readChunked(store, name) {
@@ -374,6 +437,13 @@ function setCookieValues(setCookies) {
 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}`;
 }
@@ -412,25 +482,25 @@ function decodeValue(value) {
 function resolveTransport(driver, event, options) {
 	const handed = driver.handed?.(event);
 	if (handed) return {
+		source: "handed",
 		read: () => handed.token,
 		readonly: false,
 		writable: () => true
 	};
 	const { config, name } = options;
-	const header = headerReader(driver, event, options);
-	if (config.cookie === false) return {
-		read: header,
+	const header = presentedHeader(driver, event, options);
+	if (header || config.cookie === false) return {
+		source: "header",
+		read: config.sessionHeader === false ? void 0 : () => header?.token,
+		malformed: header?.malformed,
 		readonly: false,
 		writable: () => true
 	};
 	const jar = driver.cookies(event);
 	const store = responseStore(jar);
 	const transport = {
-		read: () => {
-			const written = jar.written ? readChunked({ read: (key) => jar.written?.(key) }, name) : void 0;
-			if (written === "") return void 0;
-			return (written ?? readChunked(jar, name)) || header?.() || void 0;
-		},
+		source: "cookie",
+		read: () => cookieToken(jar, name),
 		readonly: !store,
 		writable: () => driver.writable?.(event) ?? true
 	};
@@ -471,11 +541,23 @@ function headerToken(value) {
 	if (/^bearer$/i.test(first)) return words.length === 2 ? second : void 0;
 	return words.length === 1 && first ? first : void 0;
 }
-function headerReader(driver, event, options) {
+function presentedHeader(driver, event, options) {
 	const { config, name } = options;
 	if (config.sessionHeader === false) return void 0;
 	const header = sessionHeaderName(name, config.sessionHeader);
-	return () => headerToken(driver.header(event, header));
+	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: invalidTokenError(`${driver.prefix} Invalid session token: the "${header}" header holds neither a token nor "Bearer <token>".`)
+	};
+}
+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);
@@ -521,7 +603,8 @@ function bindSession(event, config, options) {
 function sessionToken(binding) {
 	const { transport } = binding;
 	assertTokenSource(transport, { prefix: binding.driver.prefix });
-	return transport.read();
+	const session = storedSession(binding.store);
+	return session ? session.token : transport.read();
 }
 function recordSlotStore(record, slot) {
 	return {
@@ -563,43 +646,6 @@ function claimSessionName(record, options) {
 	if (held === family) return;
 	throw invalidConfigError(`${prefix} Session name "${name}" is already used by a ${held.toUpperCase()} session on this request.`);
 }
-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
-	});
-}
-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(codec, config, options) {
-	return codec.open(config, options.token, options.args).then(typedOpened);
-}
-function typedSession(state) {
-	return state;
-}
-function typedOpened(opened) {
-	return opened;
-}
 async function loadSession(binding) {
 	const { config, codec, store, args, transport } = binding;
 	await codec.assertKeys(config);
@@ -621,6 +667,7 @@ async function loadSession(binding) {
 				},
 				error: expiredSessionError({
 					id: session.id,
+					createdAt: session.createdAt,
 					expiresAt: session.expiresAt
 				})
 			});
@@ -630,6 +677,10 @@ async function loadSession(binding) {
 	}
 	const session = emptySession(binding);
 	store.set(session);
+	if (transport.malformed) {
+		await fireError(binding, transport.malformed);
+		return session;
+	}
 	const token = transport.read();
 	if (!token) return session;
 	session.token = token;
@@ -660,12 +711,7 @@ async function loadSession(binding) {
 			});
 		} else {
 			if (isJWTError(failure.error, "ERR_SESSION_TOKEN_INVALID") && isTokenFailure(failure.error)) dropSessionCookie(binding);
-			await config.hooks?.onError?.({
-				session: binding.actions.manager(binding),
-				...args,
-				error: failure.error,
-				config
-			});
+			await fireError(binding, failure.error);
 		}
 		return session;
 	}
@@ -692,6 +738,14 @@ async function rollSession(binding, session) {
 	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,
@@ -797,8 +851,7 @@ function sessionManager(binding) {
 			return (state() ?? blankSession()).data;
 		},
 		get token() {
-			const session = state();
-			return session ? session.token : sessionToken(binding);
+			return sessionToken(binding);
 		},
 		update: async (update, options) => {
 			await issueSession(binding, update, options);
@@ -822,7 +875,7 @@ function sessionActions() {
 function snapshotSession(session) {
 	return {
 		...session,
-		data: sanitizeObjectCopy(session.data)
+		data: safeJsonParse(JSON.stringify(session.data))
 	};
 }
 function defineSession(config, options) {
@@ -949,4 +1002,4 @@ function assertPinnedAlg(key, config, prefix) {
 		hint: "\"jws.signOptions.alg\""
 	});
 }
-export { bindSession, createJWECodec, createJWSCodec, defineSession, dropSession, encodeSession, invalidConfigError, issueSession, loadSession, openSessionToken, sessionActions, setCookieName, setCookieValues };
+export { bindSession, createJWECodec, createJWSCodec, defineSession, dropSession, encodeSession, invalidConfigError, issueSession, loadSession, mirrorSetCookie, openSessionToken, sessionActions, setCookieName, setCookieValues };

package/dist/_chunks/cookie.mjs

@@ -0,0 +1,50 @@
+import { mirrorSetCookie, setCookieName, setCookieValues } from "./codec-jws.mjs";
+import { parse, parseSetCookie, serialize } from "./libs/cookie-es.mjs";
+function webCookieJar(request, response) {
+	let cookies;
+	const jar = { read: (name) => (cookies ||= requestCookies(request))[name] };
+	if (response) {
+		const { headers, errHeaders } = response;
+		jar.written = (name) => setCookieValues(headers.getSetCookie())[name];
+		jar.write = (name, value, attrs) => {
+			setCookie(headers, {
+				name,
+				value,
+				...attrs
+			});
+			if (errHeaders) mirrorSetCookie(name, {
+				from: headers,
+				to: errHeaders
+			});
+		};
+	}
+	return jar;
+}
+function requestCookies(request) {
+	const header = request.get("cookie");
+	return header ? parse(header) : Object.create(null);
+}
+function setCookie(headers, cookie) {
+	const line = serialize({
+		path: "/",
+		...cookie
+	});
+	const key = cookieKey(cookie);
+	const kept = headers.getSetCookie().filter((existing) => {
+		const parsed = parseSetCookie(existing);
+		return parsed ? cookieKey(parsed) !== key : setCookieName(existing) !== cookie.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(";");
+}
+export { requestCookies, webCookieJar };

package/dist/_chunks/digest.mjs

@@ -1,5 +1,6 @@
 import { textEncoder } from "./libs/unsecure.mjs";
-import { JWTError, base64UrlStringify, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet } from "./_jwt-internal.mjs";
+import { JWTError } from "../error.mjs";
+import { base64UrlStringify, hasSymmetricSecret, isCryptoKey, isCryptoKeyPair, isJWK, isJWKSet } from "./jwt.mjs";
 const ECDSA_CURVES = /* @__PURE__ */ Object.freeze({
 	ES256: "P-256",
 	ES384: "P-384",
@@ -149,7 +150,7 @@ function unionFromJWKSet(keys, mapper, options) {
 	const algs = /* @__PURE__ */ new Set();
 	for (const k of keys) {
 		if (!isJWK(k)) continue;
-		if (k.kty === "oct" && !options?.allowSymmetric) continue;
+		if (!options?.allowSymmetric && hasSymmetricSecret(k)) continue;
 		const mapped = mapper(k);
 		if (!mapped) continue;
 		for (const a of mapped) algs.add(a);
@@ -159,6 +160,12 @@ function unionFromJWKSet(keys, mapper, options) {
 function isEd25519Signature(alg) {
 	return alg === "EdDSA" || alg === "Ed25519";
 }
+function isSameAlgorithm(a, b) {
+	return a === b || isEd25519Signature(a) && isEd25519Signature(b);
+}
+function jwkAlgServes(jwk, alg) {
+	return isSameAlgorithm(jwk.alg, alg) || jwk.kty === "oct" && alg === "dir" && isContentEncryptionAlgorithm(jwk.alg);
+}
 function jwsAlgsFromJWK(jwk) {
 	if (jwk.alg && isEd25519Signature(jwk.alg)) return ["EdDSA", "Ed25519"];
 	if (jwk.alg) return isJWSAlgorithm(jwk.alg) ? [jwk.alg] : void 0;
@@ -253,4 +260,4 @@ async function digestUrl(data, hash = "SHA-256") {
 	const bytes = typeof data === "string" ? textEncoder.encode(data) : data;
 	return base64UrlStringify(new Uint8Array(await crypto.subtle.digest(hash, bytes)));
 }
-export { ECDSA_CURVES, PBES2_ALGORITHMS, aesBitsOf, checkKeyUsage, cryptoKeyCurve, digestUrl, hashBitsOf, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, innerKeyWrapAlg, isAlgorithm, isContentEncryptionAlgorithm, isECDHESAlgorithm, isEd25519Signature, isJWSAlgorithm, isKeyManagementAlgorithm, isPBES2Algorithm, jwsHashOf, lengthOf, modulusLengthOf, namedCurveOf, pbes2HashOf, rsaOaepHashOf, shaBitsOf, unusableKey };
+export { ECDSA_CURVES, PBES2_ALGORITHMS, aesBitsOf, checkKeyUsage, cryptoKeyCurve, digestUrl, hashBitsOf, inferJWEAllowedAlgorithms, inferJWSAllowedAlgorithms, innerKeyWrapAlg, isAlgorithm, isContentEncryptionAlgorithm, isECDHESAlgorithm, isJWSAlgorithm, isKeyManagementAlgorithm, isPBES2Algorithm, isSameAlgorithm, jwkAlgServes, jwsHashOf, lengthOf, modulusLengthOf, namedCurveOf, pbes2HashOf, rsaOaepHashOf, shaBitsOf, unusableKey };