@ultimat3/auth 29.4.0 → 30.0.0

package/src/authorization-server.ts

@@ -0,0 +1,178 @@
+// Single responsibility: `authorizationServer()` — one OAuth 2.1 authorization server for an app's
+// MCP endpoint, public API, CLI or partner integrations alike. It returns plain `routes` for
+// `runtime.routes` and the calls the app's own consent and device pages make; consent itself,
+// who may be a client and what a subject becomes as an `Actor` stay the app's (axiom 8).
+
+import {
+  clientDirectory,
+  type RegisterClientInput,
+  type RegisteredClient,
+  storeClient,
+} from './authorization-server-clients';
+import {
+  type AuthorizationServerOptions,
+  resolveAuthServerConfig,
+} from './authorization-server-config';
+import { consentInvalid } from './authorization-server-errors';
+import {
+  type ReadRequestResult,
+  redirectWith,
+  screenAuthorization,
+} from './authorization-server-request';
+import { authServerMetadata, authServerRoutes } from './authorization-server-routes';
+import { resolveAccess, resolvedGrant } from './authorization-server-tokens';
+import type { AuthorizationRequest, ResolvedGrant } from './authorization-server-types';
+import type { AuthServerRoute } from './authorization-server-wire';
+import { type DeviceReading, decideDevice, readDevice } from './grant-device';
+import { randomToken, sha256Hex } from './tokens';
+
+/** RFC 6749 §4.1.2 says "maximum of 10 minutes"; two is enough for a redirect and a POST. */
+export const AUTH_CODE_TTL_MS = 2 * 60 * 1000;
+
+export interface AuthorizationServer {
+  readonly issuer: string;
+  /** Spread into `runtime.routes`. Public; no cookie authenticates them. */
+  readonly routes: readonly AuthServerRoute[];
+  /** The RFC 8414 document the metadata route serves. */
+  readonly metadata: Readonly<Record<string, unknown>>;
+  /** The consent page's read of its own URL: what to show, or the refusal to show instead. */
+  readRequest(url: string | URL): Promise<ReadRequestResult>;
+  /** The consent action's approval: the redirect URL carrying `code`, `state` and `iss`. */
+  approve(input: {
+    readonly subject: string;
+    readonly request: AuthorizationRequest;
+    /** What the person granted — the request's scopes or fewer. Defaults to all of them. */
+    readonly scopes?: readonly string[] | undefined;
+  }): Promise<string>;
+  /** The redirect URL carrying `error=access_denied`. */
+  deny(input: { readonly request: AuthorizationRequest }): Promise<string>;
+  /** `key` is the caller's bucket for user-code guesses: their address or session id. */
+  readDevice(input: { readonly userCode: string; readonly key: string }): Promise<DeviceReading>;
+  approveDevice(input: {
+    readonly subject: string;
+    readonly userCode: string;
+    readonly key: string;
+    readonly scopes: readonly string[];
+  }): Promise<void>;
+  denyDevice(input: { readonly userCode: string; readonly key: string }): Promise<void>;
+  /** A client the app registers itself — a partner's machine client, a first-party CLI. */
+  registerClient(input: RegisterClientInput): Promise<RegisteredClient>;
+  /** A live access token's grant, or `null`: unknown, expired and revoked look alike. */
+  resolve(token: string): Promise<ResolvedGrant | null>;
+  /** Every grant of `subject` (of one client when named), dead on the next lookup. */
+  revoke(input: {
+    readonly subject: string;
+    readonly clientId?: string | undefined;
+  }): Promise<number>;
+  /** Run from the app's own `task`: nothing here runs on a timer. */
+  purge(input: { readonly before: Date }): Promise<number>;
+}
+
+/** The request as the query a client would have sent — what `approve` screens a second time. */
+function requestParams(request: AuthorizationRequest): URLSearchParams {
+  const params = new URLSearchParams({
+    response_type: 'code',
+    client_id: request.client.clientId,
+    redirect_uri: request.redirectUri,
+    code_challenge: request.codeChallenge,
+    code_challenge_method: 'S256',
+    scope: request.scopes.join(' '),
+  });
+  if (request.state !== null) params.set('state', request.state);
+  if (request.resource !== null) params.set('resource', request.resource);
+  return params;
+}
+
+export function authorizationServer(options: AuthorizationServerOptions): AuthorizationServer {
+  const config = resolveAuthServerConfig(options);
+  const directory = clientDirectory(config);
+  const read = async (params: URLSearchParams): Promise<ReadRequestResult> => {
+    const clientId = params.get('client_id');
+    const client = clientId === null ? null : await directory.find(clientId);
+    return screenAuthorization(config, client, params);
+  };
+  /** The request handed back is re-screened against the store: a forged object proves nothing. */
+  const rescreen = async (request: AuthorizationRequest): Promise<AuthorizationRequest> => {
+    const again = await read(requestParams(request));
+    if (!again.ok) throw consentInvalid(again.description);
+    return again.request;
+  };
+  const subjectOf = (subject: string): string => {
+    if (subject.trim() === '') throw consentInvalid('the subject is empty');
+    return subject;
+  };
+  return {
+    issuer: config.issuer,
+    routes: authServerRoutes(config, directory),
+    metadata: authServerMetadata(config),
+    readRequest: (url) => read(new URL(url).searchParams),
+    async approve(input) {
+      const subject = subjectOf(input.subject);
+      const request = await rescreen(input.request);
+      const scopes = [...new Set(input.scopes ?? request.scopes)];
+      if (scopes.length === 0 || !scopes.every((scope) => request.scopes.includes(scope))) {
+        throw consentInvalid('the approved scopes are empty or not a subset of the requested ones');
+      }
+      const now = config.clock.now();
+      const code = randomToken(32);
+      const grantId = `g_${randomToken(16)}`;
+      // The grant exists before its code is redeemed, so a replayed code always has one to revoke.
+      await config.store.putGrant({
+        id: grantId,
+        clientId: request.client.clientId,
+        subject,
+        scopes,
+        resource: request.resource,
+        createdAt: now,
+        refreshedAt: now,
+        revokedAt: null,
+      });
+      await config.store.putCode({
+        codeHash: sha256Hex(code),
+        grantId,
+        clientId: request.client.clientId,
+        subject,
+        scopes,
+        resource: request.resource,
+        redirectUri: request.redirectUri,
+        codeChallenge: request.codeChallenge,
+        expiresAt: new Date(now.getTime() + AUTH_CODE_TTL_MS),
+        usedAt: null,
+      });
+      return redirectWith(request.redirectUri, {
+        code,
+        iss: config.issuer,
+        ...(request.state === null ? {} : { state: request.state }),
+      });
+    },
+    async deny(input) {
+      const request = await rescreen(input.request);
+      return redirectWith(request.redirectUri, {
+        error: 'access_denied',
+        iss: config.issuer,
+        ...(request.state === null ? {} : { state: request.state }),
+      });
+    },
+    readDevice: (input) => readDevice(config, input.userCode, input.key),
+    approveDevice: (input) =>
+      decideDevice(config, {
+        userCode: input.userCode,
+        key: input.key,
+        approve: { subject: subjectOf(input.subject), scopes: input.scopes },
+      }),
+    denyDevice: (input) =>
+      decideDevice(config, { userCode: input.userCode, key: input.key, approve: null }),
+    registerClient: (input) => storeClient(config, input),
+    async resolve(token) {
+      const live = await resolveAccess(config, token);
+      return live === null ? null : resolvedGrant(live.grant);
+    },
+    revoke: (input) =>
+      config.store.revokeGrants(
+        { subject: input.subject, clientId: input.clientId },
+        config.clock.now(),
+      ),
+    purge: ({ before }) =>
+      config.store.purge(before, new Date(before.getTime() - config.refreshIdleMs)),
+  };
+}

package/src/base64url.ts

@@ -0,0 +1,40 @@
+// Single responsibility: base64url, both directions, with NO imports — so the server half
+// (`tokens.ts` re-exports it) and the browser entry (`client.ts`) share one implementation and the
+// client bundle pays for nothing else. WebAuthn speaks base64url on every field of its JSON wire.
+
+const BASE64URL_UNSAFE = /[+/=]/g;
+const BASE64URL_REPLACEMENTS: Readonly<Record<string, string>> = { '+': '-', '/': '_', '=': '' };
+
+export function base64Url(bytes: Uint8Array): string {
+  let binary = '';
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(BASE64URL_UNSAFE, (char) => BASE64URL_REPLACEMENTS[char] ?? '');
+}
+
+/**
+ * The inverse of `base64Url`, for the segments of a JWT. Answers `null` rather than throwing
+ * because every caller is reading an attacker-supplied string — a `URIError` or an `InvalidCharacterError`
+ * escaping from here would turn a coded refusal into a 500, the same reason `readCookie` never throws.
+ */
+export function base64UrlBytes(segment: string): Uint8Array<ArrayBuffer> | null {
+  const padded = segment
+    .replaceAll('-', '+')
+    .replaceAll('_', '/')
+    .padEnd(Math.ceil(segment.length / 4) * 4, '=');
+  try {
+    return Uint8Array.from(atob(padded), (char) => char.charCodeAt(0));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `base64UrlBytes`, refusing every spelling but the canonical one: `atob` forgives padding,
+ * whitespace and the standard alphabet, so two strings would name one credential id. A WebAuthn
+ * field is compared as text in places (the challenge in `clientDataJSON`), so it has ONE spelling.
+ */
+export function canonicalBase64UrlBytes(segment: unknown): Uint8Array<ArrayBuffer> | null {
+  if (typeof segment !== 'string' || !/^[A-Za-z0-9_-]*$/.test(segment)) return null;
+  const bytes = base64UrlBytes(segment);
+  return bytes !== null && base64Url(bytes) === segment ? bytes : null;
+}

package/src/builtin-adapter-violation.ts

@@ -1,4 +1,4 @@
-// Single responsibility: an `x_users` unique violation as the code `MemoryAuthAdapter` answers. One
+// Single responsibility: an `x_users` (or `x_passkeys`) unique violation as the code `MemoryAuthAdapter` answers. One
 // duplicate signup must not be `X_AUTH_WRITE_FAILED` under `x dev` and `X_DB_UNIQUE_VIOLATION` in
 // production: an app that branches on the code passes its tests and misses on Postgres.
 
@@ -7,14 +7,17 @@ import { SQLSTATE, sqlState } from '@ultimat3/db';
 import { type AuthError, authUniqueViolation } from './errors';
 
 /**
- * The constraints `tables.ts` declares on `x_users`, by the names Postgres gives them. Closed: a
+ * The constraints `tables.ts` declares on `x_users` and `x_passkeys`, by the names Postgres gives them. Closed: a
  * unique index an app added to the table is the app's, and its violation travels on as the
  * database error it is rather than being reported as a column it does not cover.
  */
-const X_USERS_UNIQUE_COLUMNS: ReadonlyMap<string, string> = new Map([
-  ['x_users_email_key', 'email'],
-  ['x_users_external_id_key', 'external_id'],
-  ['x_users_pkey', 'id'],
+const UNIQUE_COLUMNS: ReadonlyMap<string, readonly [table: string, column: string]> = new Map([
+  ['x_users_email_key', ['x_users', 'email']],
+  ['x_users_external_id_key', ['x_users', 'external_id']],
+  ['x_users_pkey', ['x_users', 'id']],
+  // A credential id is globally unique (WebAuthn §7.1 step 22): a second registration of one.
+  ['x_passkeys_pkey', ['x_passkeys', 'id']],
+  ['x_passkey_evidence_pkey', ['x_passkey_evidence', 'id']],
 ]);
 
 /** How deep `DbError.sourceError` may nest before the read stops — db's own bound. */
@@ -32,12 +35,12 @@ function violatedConstraint(error: unknown): string | undefined {
 }
 
 /**
- * `undefined` for everything that is not one of `x_users`' own unique constraints, so the caller
+ * `undefined` for everything that is not one of those tables' own unique constraints, so the caller
  * rethrows what it caught. The SQLSTATE is read through db's `sqlState`, which decides by where
  * the error came from, never by the shape of a `code` field.
  */
 export function usersUniqueViolation(operation: string, error: unknown): AuthError | undefined {
   if (sqlState(error) !== SQLSTATE.uniqueViolation) return undefined;
-  const column = X_USERS_UNIQUE_COLUMNS.get(violatedConstraint(error) ?? '');
-  return column === undefined ? undefined : authUniqueViolation(operation, 'x_users', column);
+  const named = UNIQUE_COLUMNS.get(violatedConstraint(error) ?? '');
+  return named === undefined ? undefined : authUniqueViolation(operation, named[0], named[1]);
 }

package/src/builtin-adapter.ts

@@ -13,6 +13,7 @@ import type {
   AuthUser,
   AuthVerification,
   CreateUserInput,
+  PasskeyStore,
   SessionPatch,
   StoredMfaSecret,
   UserPatch,
@@ -20,6 +21,7 @@ import type {
 } from './adapter';
 import { usersUniqueViolation } from './builtin-adapter-violation';
 import { authWriteFailed } from './errors';
+import { postgresPasskeyStore } from './passkey-postgres';
 
 type Row = Readonly<Record<string, unknown>>;
 
@@ -119,18 +121,41 @@ const toApiKey = (row: Row): AuthApiKeyRecord => ({
  */
 export class PostgresAuthAdapter implements AuthAdapter {
   readonly name = 'builtin-postgres';
-  readonly #db: DbClient;
+  readonly #client: DbClient | undefined;
   readonly #clock: Clock;
+  readonly #passkeys: PasskeyStore = postgresPasskeyStore(() => this.#db);
+  // The passkey members are `passkey-postgres.ts`'s, bound once: closures over the store, no `this`.
+  readonly putPasskey: PasskeyStore['putPasskey'] = this.#passkeys.putPasskey;
+  readonly findPasskey: PasskeyStore['findPasskey'] = this.#passkeys.findPasskey;
+  readonly listPasskeys: PasskeyStore['listPasskeys'] = this.#passkeys.listPasskeys;
+  readonly advancePasskeyCounter: PasskeyStore['advancePasskeyCounter'] =
+    this.#passkeys.advancePasskeyCounter;
+  readonly deletePasskey: PasskeyStore['deletePasskey'] = this.#passkeys.deletePasskey;
+  readonly putPasskeyChallenge: PasskeyStore['putPasskeyChallenge'] =
+    this.#passkeys.putPasskeyChallenge;
+  readonly takePasskeyChallenge: PasskeyStore['takePasskeyChallenge'] =
+    this.#passkeys.takePasskeyChallenge;
+  readonly putPasskeyEvidence: PasskeyStore['putPasskeyEvidence'] =
+    this.#passkeys.putPasskeyEvidence;
+  readonly listPasskeyEvidence: PasskeyStore['listPasskeyEvidence'] =
+    this.#passkeys.listPasskeyEvidence;
 
   /**
+   * `client` omitted, every call resolves the ambient `db()` when it runs, never once here: a
+   * memoized `appAuth` is built by the process's first caller, and a client captured then
+   * ignored every later `setDbClient` and every open `withTransaction`. Passed, it is pinned.
    * `clock` is the one `MemoryAuthAdapter` takes, for the same stamp: hand over the clock
    * `defineAuth` was given, so a redemption is dated by the clock that judged its expiry.
    */
-  constructor(client: DbClient = db(), clock: Clock = systemClock) {
-    this.#db = client;
+  constructor(client?: DbClient, clock: Clock = systemClock) {
+    this.#client = client;
     this.#clock = clock;
   }
 
+  get #db(): DbClient {
+    return this.#client ?? db();
+  }
+
   /** A write to `x_users`, with the table's own unique violations answered as this package's. */
   async #writeUser(operation: string, statement: Parameters<DbClient['one']>[0]) {
     try {
@@ -427,10 +452,11 @@ export class PostgresAuthAdapter implements AuthAdapter {
 
 /**
  * The one way to build the Postgres adapter — the twin of `memoryAuthAdapter()`. The class is a
- * type in the barrel only (`X_FACTORY_NAME_SPELLING`), so `new` is never a second spelling.
+ * type in the barrel only (`X_FACTORY_NAME_SPELLING`), so `new` is never a second spelling. No
+ * `client`: each call reads the ambient `db()` as it runs, so build it once and keep it.
  */
 export function postgresAuthAdapter(
-  client: DbClient = db(),
+  client?: DbClient,
   clock: Clock = systemClock,
 ): PostgresAuthAdapter {
   return new PostgresAuthAdapter(client, clock);

package/src/cbor-encode.ts

@@ -0,0 +1,52 @@
+// Single responsibility: the CBOR ENCODER for the subset `cbor.ts` decodes — what the software
+// authenticator writes an attestation object and a COSE key with. Shortest-form heads, definite
+// lengths, keys in the order given: canonical enough for every map an authenticator sends.
+
+import type { CborValue } from './cbor';
+
+const head = (major: number, value: number): number[] => {
+  if (value < 24) return [(major << 5) | value];
+  if (value < 0x100) return [(major << 5) | 24, value];
+  if (value < 0x10000) return [(major << 5) | 25, value >> 8, value & 0xff];
+  if (value >= 2 ** 32) {
+    const bytes: number[] = [];
+    for (let rest = value, index = 0; index < 8; index += 1, rest = Math.floor(rest / 256)) {
+      bytes.unshift(rest % 256);
+    }
+    return [(major << 5) | 27, ...bytes];
+  }
+  return [
+    (major << 5) | 26,
+    (value >>> 24) & 0xff,
+    (value >> 16) & 0xff,
+    (value >> 8) & 0xff,
+    value & 0xff,
+  ];
+};
+
+/** One CBOR item, for the subset `cbor.ts` reads. */
+export function cborEncode(value: CborValue): Uint8Array {
+  const out: number[] = [];
+  const walk = (item: CborValue): void => {
+    if (typeof item === 'number') out.push(...(item >= 0 ? head(0, item) : head(1, -1 - item)));
+    else if (typeof item === 'string') {
+      const bytes = new TextEncoder().encode(item);
+      out.push(...head(3, bytes.length), ...bytes);
+    } else if (item instanceof Uint8Array) out.push(...head(2, item.length), ...item);
+    else if (item === false) out.push(0xf4);
+    else if (item === true) out.push(0xf5);
+    else if (item === null) out.push(0xf6);
+    else if (item instanceof Map) {
+      out.push(...head(5, item.size));
+      for (const [key, entry] of item) {
+        walk(key);
+        walk(entry);
+      }
+    } else if (Array.isArray(item)) {
+      out.push(...head(4, item.length));
+      for (const entry of item) walk(entry);
+    }
+  };
+  walk(value);
+  return Uint8Array.from(out);
+}

package/src/cbor.ts

@@ -0,0 +1,129 @@
+// Single responsibility: the CBOR subset WebAuthn sends (RFC 8949, CTAP2 canonical form) —
+// definite-length integers, byte and text strings, arrays, maps and the three simple values —
+// decoded from attacker-supplied bytes. Anything else (tags, floats, indefinite lengths) is a
+// refusal, never a guess: the attestation object and the COSE key use none of it.
+
+/** A decoded item. Maps are a `Map`, never a record indexed by a key the sender chose. */
+export type CborValue =
+  | number
+  | string
+  | boolean
+  | null
+  | Uint8Array
+  | readonly CborValue[]
+  | ReadonlyMap<number | string, CborValue>;
+
+/** What one item decoded to, and the offset of the first byte after it. */
+export interface CborItem {
+  readonly value: CborValue;
+  readonly end: number;
+}
+
+/** A nested key inside a COSE key is depth 2; anything near this is not WebAuthn. */
+const MAX_DEPTH = 8;
+/** Items in one array or map. A COSE key has five; an attestation object three. */
+const MAX_ITEMS = 64;
+
+const decoder = new TextDecoder('utf-8', { fatal: true });
+
+/** `null` for every way the bytes are not one well-formed item of the subset. */
+export function decodeCborItem(bytes: Uint8Array, start = 0): CborItem | null {
+  try {
+    return item(bytes, start, 0);
+  } catch {
+    // Only `TextDecoder`'s fatal throw reaches here: invalid UTF-8 in a text string.
+    return null;
+  }
+}
+
+/** The whole buffer as exactly one item — trailing bytes are a refusal. */
+export function decodeCbor(bytes: Uint8Array): CborValue | undefined {
+  const decoded = decodeCborItem(bytes);
+  return decoded !== null && decoded.end === bytes.length ? decoded.value : undefined;
+}
+
+interface Head {
+  readonly major: number;
+  readonly argument: number;
+  readonly next: number;
+}
+
+function head(bytes: Uint8Array, at: number): Head | null {
+  const initial = bytes[at];
+  if (initial === undefined) return null;
+  const major = initial >> 5;
+  const info = initial & 0x1f;
+  if (info < 24) return { major, argument: info, next: at + 1 };
+  const width = info === 24 ? 1 : info === 25 ? 2 : info === 26 ? 4 : info === 27 ? 8 : 0;
+  // 28-30 are reserved, 31 is indefinite length: neither is in the subset.
+  if (width === 0 || at + 1 + width > bytes.length) return null;
+  let argument = 0;
+  for (let index = 1; index <= width; index += 1) {
+    argument = argument * 256 + (bytes[at + index] ?? 0);
+  }
+  if (!Number.isSafeInteger(argument)) return null;
+  return { major, argument, next: at + 1 + width };
+}
+
+function item(bytes: Uint8Array, at: number, depth: number): CborItem | null {
+  if (depth > MAX_DEPTH) return null;
+  const parsed = head(bytes, at);
+  if (parsed === null) return null;
+  const { major, argument, next } = parsed;
+  switch (major) {
+    case 0:
+      return { value: argument, end: next };
+    case 1:
+      return { value: -1 - argument, end: next };
+    case 2:
+    case 3: {
+      const end = next + argument;
+      if (end > bytes.length) return null;
+      const slice = bytes.slice(next, end);
+      return { value: major === 2 ? slice : decoder.decode(slice), end };
+    }
+    case 4:
+      return list(bytes, next, argument, depth);
+    case 5:
+      return map(bytes, next, argument, depth);
+    case 7:
+      if (argument === 20) return { value: false, end: next };
+      if (argument === 21) return { value: true, end: next };
+      if (argument === 22) return { value: null, end: next };
+      return null;
+    default:
+      return null;
+  }
+}
+
+function list(bytes: Uint8Array, at: number, count: number, depth: number): CborItem | null {
+  if (count > MAX_ITEMS) return null;
+  const values: CborValue[] = [];
+  let cursor = at;
+  for (let index = 0; index < count; index += 1) {
+    const entry = item(bytes, cursor, depth + 1);
+    if (entry === null) return null;
+    values.push(entry.value);
+    cursor = entry.end;
+  }
+  return { value: values, end: cursor };
+}
+
+function map(bytes: Uint8Array, at: number, count: number, depth: number): CborItem | null {
+  if (count > MAX_ITEMS) return null;
+  const entries = new Map<number | string, CborValue>();
+  let cursor = at;
+  for (let index = 0; index < count; index += 1) {
+    const key = item(bytes, cursor, depth + 1);
+    if (key === null || (typeof key.value !== 'number' && typeof key.value !== 'string')) {
+      return null;
+    }
+    // A repeated key is how two parsers disagree about one object: refused, never last-wins.
+    if (entries.has(key.value)) return null;
+    const entry = item(bytes, key.end, depth + 1);
+    if (entry === null) return null;
+    entries.set(key.value, entry.value);
+    cursor = entry.end;
+  }
+  return { value: entries, end: cursor };
+}

package/src/client-scope.ts

@@ -4,7 +4,7 @@
 // the HTML is cacheable by a browser and readable by every script on the page.
 
 import type { Actor } from '@ultimat3/core';
-import { logger } from '@ultimat3/core';
+import { hmac, logger } from '@ultimat3/core';
 import { AuthError } from './errors';
 
 /** 128 bits: a scope only has to differ between principals, never to authenticate anyone. */
@@ -35,10 +35,7 @@ export function clientScopeOf(actor: Actor, options: ClientScopeOptions = {}): s
     actor.onBehalfOf?.actorKind ?? null,
     actor.onBehalfOf?.actorId ?? null,
   ]);
-  return new Bun.CryptoHasher('sha256', scopeKey(options))
-    .update(material)
-    .digest('hex')
-    .slice(0, SCOPE_HEX_CHARS);
+  return hmac('sha256', scopeKey(options), material, 'hex').slice(0, SCOPE_HEX_CHARS);
 }
 
 function scopeKey(options: ClientScopeOptions): string {

package/src/client.ts

@@ -0,0 +1,16 @@
+// `@ultimat3/auth/client` — THE browser entry of this package: the passkey ceremony's browser half
+// and the wire types it speaks, and nothing that drags the server half along. The `.` barrel
+// reaches `@ultimat3/db`, argon2 and the error table; this entry's graph is `passkey-client.ts`
+// and `base64url.ts`, held there by `client-bundle.test.ts`.
+//
+//   import { newPasskey, getPasskey } from '@ultimat3/auth/client';
+
+export type { PasskeyClientHost, PasskeyOutcome } from './passkey-client';
+export { getPasskey, newPasskey, passkeysSupported } from './passkey-client';
+export type {
+  PasskeyAssertionResponse,
+  PasskeyCreationOptions,
+  PasskeyCredentialDescriptor,
+  PasskeyRegistrationResponse,
+  PasskeyRequestOptions,
+} from './passkey-wire';