@zeyolabs/kit 0.0.0-stage → 2026.11.6

package/auth/sessions/magic-link/magic-link.ts

@@ -0,0 +1,71 @@
+import { and, eq, gt, isNull, lt, or } from 'drizzle-orm';
+
+import type { AuthDb } from '../../config';
+
+import { Crypto } from '../../../utils/crypto';
+import { authTokens } from '../../schema';
+
+// Magic-link tokens. The emailed secret is 256 random bits; only its sha256 is stored, so a leaked
+// row can't be replayed. A token is consumed by a single atomic UPDATE, so two clicks (or a mail
+// scanner racing the user) can't both sign in.
+
+const MAGIC_LINK_TTL_MS = 15 * 60 * 1000;
+
+/** Unused, unexpired links allowed per email at once: stops someone flooding an inbox. */
+const MAX_LIVE_LINKS = 3;
+
+/** A fresh token for `email`, or `null` when it already has `MAX_LIVE_LINKS` live ones. */
+async function issueMagicLinkToken(
+	db: AuthDb,
+	email: string,
+	now = Date.now()
+): Promise<null | string> {
+	// Housekeeping first: used or expired rows for this email are never needed again.
+	await db
+		.delete(authTokens)
+		.where(
+			and(eq(authTokens.email, email), or(lt(authTokens.expiresAt, now), gt(authTokens.usedAt, 0)))
+		);
+	const live = await db
+		.select({ tokenHash: authTokens.tokenHash })
+		.from(authTokens)
+		.where(eq(authTokens.email, email));
+	if (live.length >= MAX_LIVE_LINKS) return null;
+
+	const token = Crypto.getRandomSecret(32);
+	await db.insert(authTokens).values({
+		createdAt: now,
+		email,
+		expiresAt: now + MAGIC_LINK_TTL_MS,
+		tokenHash: Crypto.hashSecret(token),
+	});
+	return token;
+}
+
+/** Uses a token up and returns its email, or `null` if it is unknown, used or expired. */
+async function consumeMagicLinkToken(
+	db: AuthDb,
+	token: string,
+	now = Date.now()
+): Promise<null | string> {
+	if (!/^[0-9a-f]{64}$/.test(token)) return null;
+	const [row] = await db
+		.update(authTokens)
+		.set({ usedAt: now })
+		.where(
+			and(
+				eq(authTokens.tokenHash, Crypto.hashSecret(token)),
+				isNull(authTokens.usedAt),
+				gt(authTokens.expiresAt, now)
+			)
+		)
+		.returning({ email: authTokens.email });
+	return row?.email ?? null;
+}
+
+export const MagicLink = {
+	consume: consumeMagicLinkToken,
+	issue: issueMagicLinkToken,
+	MAX_LIVE: MAX_LIVE_LINKS,
+	TTL_MS: MAGIC_LINK_TTL_MS,
+};

package/auth/sessions/passkeys/client.ts

@@ -0,0 +1,115 @@
+// Browser side of the passkey endpoints in `sveltekit/routes.ts`. Uses the WebAuthn JSON helpers
+// (`PublicKeyCredential.parse*OptionsFromJSON`, `credential.toJSON()`), available in every
+// current browser. Import only from client code (event handlers), never at module scope on the
+// server.
+
+type JsonCredential = { toJSON(): unknown };
+
+type PublicKeyCredentialStatic = {
+	isConditionalMediationAvailable?: () => Promise<boolean>;
+	parseCreationOptionsFromJSON(options: unknown): unknown;
+	parseRequestOptionsFromJSON(options: unknown): unknown;
+};
+
+type CredentialsContainer = {
+	create(options: { publicKey: unknown }): Promise<JsonCredential | null>;
+	get(options: {
+		mediation?: 'conditional' | 'optional';
+		publicKey: unknown;
+		signal?: AbortSignal;
+	}): Promise<JsonCredential | null>;
+};
+
+/** Whether this browser can use passkeys at all (and has the JSON helpers we rely on). */
+function passkeysSupported(): boolean {
+	const pkc = (globalThis as { PublicKeyCredential?: PublicKeyCredentialStatic })
+		.PublicKeyCredential;
+	return typeof pkc?.parseRequestOptionsFromJSON === 'function';
+}
+
+/** Whether the browser can offer passkeys from the email field's autofill. */
+async function conditionalPasskeysSupported(): Promise<boolean> {
+	if (!passkeysSupported()) return false;
+	const pkc = (globalThis as unknown as { PublicKeyCredential: PublicKeyCredentialStatic })
+		.PublicKeyCredential;
+	return (await pkc.isConditionalMediationAvailable?.()) ?? false;
+}
+
+export class PasskeyClientError extends Error {
+	override name = 'PasskeyClientError';
+	constructor(
+		message: string,
+		/** The server asked for a fresh sign-in before adding a passkey. */
+		readonly reauth = false
+	) {
+		super(message);
+	}
+}
+
+async function post(path: string, body?: unknown): Promise<Record<string, unknown>> {
+	const response = await fetch(path, {
+		body: JSON.stringify(body ?? {}),
+		headers: { 'content-type': 'application/json' },
+		method: 'POST',
+	});
+	const data = (await response.json().catch(() => ({}))) as Record<string, unknown>;
+	if (!response.ok) {
+		throw new PasskeyClientError(String(data.message ?? 'Request failed'), data.reauth === true);
+	}
+	return data;
+}
+
+function api() {
+	const g = globalThis as unknown as {
+		navigator: { credentials: CredentialsContainer };
+		PublicKeyCredential: PublicKeyCredentialStatic;
+	};
+	return { credentials: g.navigator.credentials, pkc: g.PublicKeyCredential };
+}
+
+/** True when the user dismissed the browser prompt (not worth showing an error for). */
+function isPasskeyCancel(err: unknown): boolean {
+	return err instanceof Error && (err.name === 'NotAllowedError' || err.name === 'AbortError');
+}
+
+/**
+ * Signs in with a passkey and returns where to go next. With `conditional`, the request waits
+ * quietly for the user to pick a passkey from the email field's autofill (the field needs
+ * `autocomplete="username webauthn"`); abort it with `signal` before starting a modal one.
+ */
+async function signInWithPasskey(
+	options: { conditional?: boolean; next?: string; signal?: AbortSignal } = {}
+): Promise<string> {
+	const { credentials, pkc } = api();
+	const publicKey = pkc.parseRequestOptionsFromJSON(await post('/auth/passkey/login-options'));
+	const credential = await credentials.get({
+		mediation: options.conditional ? 'conditional' : 'optional',
+		publicKey,
+		signal: options.signal,
+	});
+	if (!credential) throw new PasskeyClientError('No passkey was chosen');
+	const result = await post('/auth/passkey/login', {
+		credential: credential.toJSON(),
+		next: options.next,
+	});
+	return String(result.redirect ?? '/');
+}
+
+/** Creates a passkey for the signed-in user and saves it under `name`. */
+async function addPasskey(name: string): Promise<void> {
+	const { credentials, pkc } = api();
+	const options = await post('/auth/passkey/register-options');
+	const credential = await credentials.create({
+		publicKey: pkc.parseCreationOptionsFromJSON(options),
+	});
+	if (!credential) throw new PasskeyClientError('No passkey was created');
+	await post('/auth/passkey/register', { credential: credential.toJSON(), name });
+}
+
+export const PasskeyClient = {
+	add: addPasskey,
+	conditionalSupported: conditionalPasskeysSupported,
+	isCancel: isPasskeyCancel,
+	signIn: signInWithPasskey,
+	supported: passkeysSupported,
+};

package/auth/sessions/passkeys/passkeys.ts

@@ -0,0 +1,295 @@
+import {
+	decodePKIXECDSASignature,
+	decodeSEC1PublicKey,
+	p256,
+	verifyECDSASignature,
+} from '@oslojs/crypto/ecdsa';
+import {
+	decodePKCS1RSAPublicKey,
+	RSAPublicKey,
+	sha256ObjectIdentifier,
+	verifyRSASSAPKCS1v15Signature,
+} from '@oslojs/crypto/rsa';
+import { sha256 } from '@oslojs/crypto/sha2';
+import { constantTimeEqual } from '@oslojs/crypto/subtle';
+import { decodeBase64urlIgnorePadding, encodeBase64urlNoPadding } from '@oslojs/encoding';
+import {
+	ClientDataType,
+	coseAlgorithmES256,
+	coseAlgorithmRS256,
+	coseEllipticCurveP256,
+	COSEKeyType,
+	createAssertionSignatureMessage,
+	parseAttestationObject,
+	parseAuthenticatorData,
+	parseClientDataJSON,
+} from '@oslojs/webauthn';
+import { and, eq } from 'drizzle-orm';
+import { z } from 'zod';
+
+import type { AuthDb } from '../../config';
+import type { AuthUser } from '../sessions';
+
+import { passkeys } from '../../schema';
+
+// WebAuthn passkeys, verified server-side with oslo (pure JS, runs on Workers). Only what a
+// passkey sign-in needs: no attestation (we ask for `none` and never trust a vendor's chain),
+// user verification required, ES256 and RS256 keys. Options and responses travel as the
+// WebAuthn JSON forms, so the browser side is `PublicKeyCredential.parse*OptionsFromJSON` and
+// `credential.toJSON()` (see `client.ts`).
+
+const ALGORITHMS = [coseAlgorithmES256, coseAlgorithmRS256];
+
+/** Adding a passkey needs a session signed in this recently, so a stolen session cookie can't
+ *  quietly plant a lasting credential. */
+const FRESH_SESSION_MS = 15 * 60 * 1000;
+
+/** The relying party: where the ceremony runs. `id` is the hostname (`origin` without scheme). */
+export type RelyingParty = { id: string; name: string; origin: string };
+
+export class PasskeyError extends Error {
+	override name = 'PasskeyError';
+}
+
+export const RegistrationResponse = z.object({
+	id: z.string().min(1).max(1024),
+	rawId: z.string().min(1).max(1024),
+	response: z.object({
+		attestationObject: z.string().min(1),
+		clientDataJSON: z.string().min(1),
+		transports: z.array(z.string().max(32)).max(8).optional(),
+	}),
+	type: z.literal('public-key'),
+});
+export type RegistrationResponse = z.infer<typeof RegistrationResponse>;
+
+export const AuthenticationResponse = z.object({
+	id: z.string().min(1).max(1024),
+	rawId: z.string().min(1).max(1024),
+	response: z.object({
+		authenticatorData: z.string().min(1),
+		clientDataJSON: z.string().min(1),
+		signature: z.string().min(1),
+		userHandle: z.string().nullish(),
+	}),
+	type: z.literal('public-key'),
+});
+export type AuthenticationResponse = z.infer<typeof AuthenticationResponse>;
+
+/** A fresh challenge, base64url. The caller keeps it (a short-lived cookie) until the response. */
+function newChallenge(): string {
+	return encodeBase64urlNoPadding(crypto.getRandomValues(new Uint8Array(32)));
+}
+
+/** `PublicKeyCredentialCreationOptionsJSON` for adding a passkey to `user`. */
+function registrationOptions(
+	rp: RelyingParty,
+	user: AuthUser,
+	challenge: string,
+	existingIds: string[]
+) {
+	return {
+		attestation: 'none',
+		authenticatorSelection: { residentKey: 'required', userVerification: 'required' },
+		challenge,
+		excludeCredentials: existingIds.map((id) => ({ id, type: 'public-key' })),
+		pubKeyCredParams: ALGORITHMS.map((alg) => ({ alg, type: 'public-key' })),
+		rp: { id: rp.id, name: rp.name },
+		timeout: 120_000,
+		user: {
+			displayName: user.email,
+			id: encodeBase64urlNoPadding(new TextEncoder().encode(String(user.id))),
+			name: user.email,
+		},
+	};
+}
+
+/** `PublicKeyCredentialRequestOptionsJSON` for a username-less (discoverable) sign-in. */
+function authenticationOptions(rp: RelyingParty, challenge: string) {
+	return {
+		allowCredentials: [],
+		challenge,
+		rpId: rp.id,
+		timeout: 120_000,
+		userVerification: 'required',
+	};
+}
+
+/** A P-256 point as uncompressed SEC1 (`04 || x || y`, each coordinate left-padded to 32 bytes).
+ *  oslo's `encodeSEC1Uncompressed` pads a coordinate with a leading zero byte on the wrong end,
+ *  which breaks about 1 in 256 keys. */
+function encodeP256Point(x: bigint, y: bigint): Uint8Array {
+	const out = new Uint8Array(65);
+	out[0] = 0x04;
+	for (const [offset, value] of [
+		[1, x],
+		[33, y],
+	] as const) {
+		let v = value;
+		for (let i = offset + 31; i >= offset; i--) {
+			out[i] = Number(v & 0xffn);
+			v >>= 8n;
+		}
+	}
+	return out;
+}
+
+function decode(value: string, what: string): Uint8Array {
+	try {
+		return decodeBase64urlIgnorePadding(value);
+	} catch {
+		throw new PasskeyError(`Malformed ${what}`);
+	}
+}
+
+function checkClientData(
+	clientDataJSON: Uint8Array,
+	type: ClientDataType,
+	challenge: string,
+	rp: RelyingParty
+) {
+	const clientData = parseClientDataJSON(clientDataJSON);
+	if (clientData.type !== type) throw new PasskeyError('Wrong ceremony type');
+	if (!constantTimeEqual(clientData.challenge, decode(challenge, 'challenge'))) {
+		throw new PasskeyError('Challenge mismatch');
+	}
+	if (clientData.origin !== rp.origin) throw new PasskeyError('Origin mismatch');
+	if (clientData.crossOrigin) throw new PasskeyError('Cross-origin ceremony');
+}
+
+/** Verifies a registration response and returns the credential to store. */
+function verifyRegistration(response: RegistrationResponse, challenge: string, rp: RelyingParty) {
+	checkClientData(
+		decode(response.response.clientDataJSON, 'clientDataJSON'),
+		ClientDataType.Create,
+		challenge,
+		rp
+	);
+	const { authenticatorData } = parseAttestationObject(
+		decode(response.response.attestationObject, 'attestationObject')
+	);
+	if (!authenticatorData.verifyRelyingPartyIdHash(rp.id)) throw new PasskeyError('Wrong RP id');
+	if (!authenticatorData.userPresent || !authenticatorData.userVerified) {
+		throw new PasskeyError('User not verified');
+	}
+	const credential = authenticatorData.credential;
+	if (!credential) throw new PasskeyError('No credential');
+	const id = encodeBase64urlNoPadding(credential.id);
+	if (id !== response.rawId) throw new PasskeyError('Credential id mismatch');
+
+	const key = credential.publicKey;
+	const algorithm = key.algorithm();
+	let publicKey: Uint8Array;
+	if (algorithm === coseAlgorithmES256 && key.type() === COSEKeyType.EC2) {
+		const ec2 = key.ec2();
+		if (ec2.curve !== coseEllipticCurveP256) throw new PasskeyError('Unsupported curve');
+		publicKey = encodeP256Point(ec2.x, ec2.y);
+	} else if (algorithm === coseAlgorithmRS256 && key.type() === COSEKeyType.RSA) {
+		const rsa = key.rsa();
+		publicKey = new RSAPublicKey(rsa.n, rsa.e).encodePKCS1();
+	} else {
+		throw new PasskeyError('Unsupported algorithm');
+	}
+	const transports = (response.response.transports ?? []).join(',');
+	return { algorithm, id, publicKey, signCount: authenticatorData.signatureCounter, transports };
+}
+
+/** Verifies a sign-in response against the stored passkey; returns the new signature counter. */
+function verifyAuthentication(
+	response: AuthenticationResponse,
+	challenge: string,
+	rp: RelyingParty,
+	stored: { algorithm: number; publicKey: Uint8Array; signCount: number }
+): number {
+	const clientDataJSON = decode(response.response.clientDataJSON, 'clientDataJSON');
+	checkClientData(clientDataJSON, ClientDataType.Get, challenge, rp);
+	const rawAuthenticatorData = decode(response.response.authenticatorData, 'authenticatorData');
+	const authenticatorData = parseAuthenticatorData(rawAuthenticatorData);
+	if (!authenticatorData.verifyRelyingPartyIdHash(rp.id)) throw new PasskeyError('Wrong RP id');
+	if (!authenticatorData.userPresent || !authenticatorData.userVerified) {
+		throw new PasskeyError('User not verified');
+	}
+
+	const hash = sha256(createAssertionSignatureMessage(rawAuthenticatorData, clientDataJSON));
+	const signature = decode(response.response.signature, 'signature');
+	let valid = false;
+	try {
+		if (stored.algorithm === coseAlgorithmES256) {
+			const key = decodeSEC1PublicKey(p256, stored.publicKey);
+			valid = verifyECDSASignature(key, hash, decodePKIXECDSASignature(signature));
+		} else if (stored.algorithm === coseAlgorithmRS256) {
+			const key = decodePKCS1RSAPublicKey(stored.publicKey);
+			valid = verifyRSASSAPKCS1v15Signature(key, sha256ObjectIdentifier, hash, signature);
+		}
+	} catch {
+		valid = false;
+	}
+	if (!valid) throw new PasskeyError('Bad signature');
+
+	// Authenticators that count (security keys) must move forward; synced passkeys always send 0.
+	const count = authenticatorData.signatureCounter;
+	if ((count !== 0 || stored.signCount !== 0) && count <= stored.signCount) {
+		throw new PasskeyError('Signature counter went backwards: possible cloned key');
+	}
+	return count;
+}
+
+async function listPasskeys(db: AuthDb, userId: number) {
+	return db
+		.select({
+			createdAt: passkeys.createdAt,
+			id: passkeys.id,
+			lastUsedAt: passkeys.lastUsedAt,
+			name: passkeys.name,
+		})
+		.from(passkeys)
+		.where(eq(passkeys.userId, userId))
+		.orderBy(passkeys.createdAt);
+}
+
+async function findPasskey(db: AuthDb, id: string) {
+	const [row] = await db.select().from(passkeys).where(eq(passkeys.id, id)).limit(1);
+	return row ?? null;
+}
+
+async function savePasskey(
+	db: AuthDb,
+	userId: number,
+	name: string,
+	credential: ReturnType<typeof verifyRegistration>,
+	now = Date.now()
+): Promise<void> {
+	await db.insert(passkeys).values({ ...credential, createdAt: now, name, userId });
+}
+
+async function recordPasskeyUse(
+	db: AuthDb,
+	id: string,
+	signCount: number,
+	now = Date.now()
+): Promise<void> {
+	await db.update(passkeys).set({ lastUsedAt: now, signCount }).where(eq(passkeys.id, id));
+}
+
+/** Deletes one of `userId`'s passkeys; `false` if it isn't theirs. */
+async function deletePasskey(db: AuthDb, userId: number, id: string): Promise<boolean> {
+	const deleted = await db
+		.delete(passkeys)
+		.where(and(eq(passkeys.id, id), eq(passkeys.userId, userId)))
+		.returning({ id: passkeys.id });
+	return deleted.length > 0;
+}
+
+export const Passkeys = {
+	authenticationOptions,
+	delete: deletePasskey,
+	find: findPasskey,
+	FRESH_SESSION_MS,
+	list: listPasskeys,
+	newChallenge,
+	recordUse: recordPasskeyUse,
+	registrationOptions,
+	save: savePasskey,
+	verifyAuthentication,
+	verifyRegistration,
+};

package/auth/sessions/sessions.ts

@@ -0,0 +1,101 @@
+import { and, eq, lt } from 'drizzle-orm';
+
+import type { AuthDb } from '../config';
+
+import { Crypto } from '../../utils/crypto';
+import { sessions, users } from '../schema';
+
+// Framework-agnostic session store: every function takes the db, so a plain Worker (no SvelteKit,
+// no `configureAuth`) can use it too.
+
+/** Session lifetime and sliding renewal: a session used with less than `RENEW_BELOW_MS` left is
+ *  pushed out to a full `SESSION_LIFETIME_MS` again. */
+const SESSION_LIFETIME_MS = 30 * 24 * 60 * 60 * 1000;
+const SESSION_RENEW_BELOW_MS = 15 * 24 * 60 * 60 * 1000;
+
+/** Session cookie: host-only (no `domain`), `secure` always (browsers treat localhost as secure). */
+const sessionCookieAttributes = {
+	httpOnly: true,
+	path: '/',
+	sameSite: 'lax',
+	secure: true,
+} as const;
+
+export type AuthSession = { createdAt: number; expiresAt: number; id: string };
+export type AuthUser = { avatarUrl: null | string; email: string; id: number; name: string };
+
+/** Split a `<id>.<secret>` session cookie value. `null` unless it is exactly two parts. */
+function splitSessionToken(token: string): null | { id: string; secret: string } {
+	const parts = token.split('.');
+	if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+	return { id: parts[0], secret: parts[1] };
+}
+
+function needsRenewal(expiresAt: number, now: number): boolean {
+	return expiresAt - now < SESSION_RENEW_BELOW_MS;
+}
+
+/** Inserts a session (hashed secret) and returns the `<id>.<secret>` cookie value. Also clears the
+ *  user's expired rows, so the table doesn't grow forever. */
+async function createSession(db: AuthDb, userId: number, now = Date.now()) {
+	const id = Crypto.getRandomSecret(16);
+	const secret = Crypto.getRandomSecret(32);
+	const expiresAt = now + SESSION_LIFETIME_MS;
+	await db.delete(sessions).where(and(eq(sessions.userId, userId), lt(sessions.expiresAt, now)));
+	await db.insert(sessions).values({
+		createdAt: now,
+		expiresAt,
+		id,
+		lastUsedAt: now,
+		secretHash: Crypto.hashSecret(secret),
+		userId,
+	});
+	return { expiresAt, id, token: `${id}.${secret}` };
+}
+
+/** The live session and its user for a cookie value, or `null` if unknown, forged or expired. */
+async function validateSession(
+	db: AuthDb,
+	token: string,
+	now = Date.now()
+): Promise<null | { session: AuthSession; user: AuthUser }> {
+	const split = splitSessionToken(token);
+	if (!split) return null;
+	const [row] = await db
+		.select({ session: sessions, user: users })
+		.from(sessions)
+		.innerJoin(users, eq(users.id, sessions.userId))
+		.where(eq(sessions.id, split.id))
+		.limit(1);
+	if (!row || !Crypto.verifySecret(split.secret, row.session.secretHash)) return null;
+	if (row.session.expiresAt <= now) return null;
+	const { avatarUrl, email, id, name } = row.user;
+	const { createdAt, expiresAt } = row.session;
+	return {
+		session: { createdAt, expiresAt, id: row.session.id },
+		user: { avatarUrl, email, id, name },
+	};
+}
+
+/** Pushes a session's expiry out to a full lifetime again; returns the new expiry. */
+async function renewSession(db: AuthDb, sessionId: string, now = Date.now()) {
+	const expiresAt = now + SESSION_LIFETIME_MS;
+	await db.update(sessions).set({ expiresAt, lastUsedAt: now }).where(eq(sessions.id, sessionId));
+	return expiresAt;
+}
+
+async function deleteSession(db: AuthDb, sessionId: string): Promise<void> {
+	await db.delete(sessions).where(eq(sessions.id, sessionId));
+}
+
+export const Sessions = {
+	cookieAttributes: sessionCookieAttributes,
+	create: createSession,
+	delete: deleteSession,
+	LIFETIME_MS: SESSION_LIFETIME_MS,
+	needsRenewal,
+	renew: renewSession,
+	RENEW_BELOW_MS: SESSION_RENEW_BELOW_MS,
+	splitToken: splitSessionToken,
+	validate: validateSession,
+};

package/auth/sveltekit/loads.ts

@@ -0,0 +1,59 @@
+import type { RequestEvent } from '@sveltejs/kit';
+
+import { redirect } from '@sveltejs/kit';
+
+import { Invites } from '../accounts/invites';
+import { Auth } from '../config';
+import { AuthHandle } from '../sessions/handle';
+import { Passkeys } from '../sessions/passkeys/passkeys';
+import { Login } from './login';
+
+type LoadEvent = Pick<RequestEvent, 'locals' | 'url'>;
+
+/** The login page's server load: `export { loginLoad as load } from '@zeyolabs/kit/auth/sveltekit/loads'`.
+ *  A signed-in visitor goes straight on to `next`, unless they arrived with a link token. */
+function loginLoad(event: LoadEvent) {
+	const { accessEmail, user } = AuthHandle.locals(event as RequestEvent);
+	const params = event.url.searchParams;
+	const next = Login.safeNext(params.get('next') ?? '/');
+	const token = params.get('token');
+	if (user && !token) redirect(303, next);
+	return {
+		accessEmail,
+		error: Login.errorMessage(params.get('error')),
+		next,
+		sent: params.has('sent'),
+		token,
+	};
+}
+
+/** For a settings page that manages passkeys. `fresh` says whether adding one is allowed now
+ *  without signing in again. */
+async function passkeysLoad(event: LoadEvent) {
+	const { session, user } = AuthHandle.locals(event as RequestEvent);
+	if (!session || !user) redirect(303, Auth.config().loginPath);
+	return {
+		fresh: Date.now() - session.createdAt <= Passkeys.FRESH_SESSION_MS,
+		passkeys: await Passkeys.list(Auth.config().db(), user.id),
+	};
+}
+
+/** The invite page's load (`/invite?token=`): who invited whom to what. Signed-out visitors are
+ *  already sent to the login page by the auth handle and come back here. */
+async function inviteLoad(event: LoadEvent) {
+	const { user } = AuthHandle.locals(event as RequestEvent);
+	const token = event.url.searchParams.get('token') ?? '';
+	const invite = await Invites.find(Auth.config().db(), token);
+	return {
+		error: event.url.searchParams.get('error'),
+		invite: invite && { accountName: invite.account.name, email: invite.email },
+		signedInAs: user?.email ?? null,
+		token,
+	};
+}
+
+export const AuthLoads = {
+	invite: inviteLoad,
+	login: loginLoad,
+	passkeys: passkeysLoad,
+};

package/auth/sveltekit/login.ts

@@ -0,0 +1,28 @@
+// The login page's side of the auth routes: where to go after signing in, and error copy.
+
+/** Login-page error codes; the app's login page maps them to copy with `loginErrorMessage`. */
+export type LoginError = 'expired' | 'mismatch' | 'not_allowed' | 'passkey' | 'send';
+
+const LOGIN_ERRORS: Record<LoginError, string> = {
+	expired: 'That sign-in link has expired or was already used. Request a new one.',
+	mismatch: 'Sign in with the same email you used for Cloudflare Access.',
+	not_allowed: 'That email is not allowed to sign in here.',
+	passkey: 'That passkey could not be verified. Try again or use an email link.',
+	send: 'We could not send the email. Check the address and try again.',
+};
+
+/** A same-site path to go to after sign-in: never another origin (`//x`, `/\x`, `https:`). */
+function safeNext(next: unknown): string {
+	if (typeof next !== 'string' || !next.startsWith('/') || /^\/[/\\]/.test(next)) return '/';
+	return next;
+}
+
+/** Copy for a login page's `?error=` code; `null` for none or an unknown one. */
+function loginErrorMessage(code: null | string): null | string {
+	return code && code in LOGIN_ERRORS ? LOGIN_ERRORS[code as LoginError] : null;
+}
+
+export const Login = {
+	errorMessage: loginErrorMessage,
+	safeNext,
+};