@lunora/auth 1.0.0-alpha.24 → 1.0.0-alpha.240

package/dist/index.d.mts

@@ -1,578 +1,448 @@
-export { lunoraAuthAdapter, lunoraD1Adapter } from "./adapter.mjs";
-import { LunoraError } from '@lunora/errors';
-import { L as LunoraAuth, a as LunoraAuthOptions } from "./packem_shared/create-auth.d-Mwhb4gSc.mjs";
-export { c as createAuth, r as resolveAuthOptions } from "./packem_shared/create-auth.d-Mwhb4gSc.mjs";
+import { D as DoStorageLike } from "./packem_shared/adapter.d-CaPwF2v3.mjs";
+export { l as lunoraAuthAdapter, a as lunoraD1Adapter, b as lunoraDoAdapter } from "./packem_shared/adapter.d-CaPwF2v3.mjs";
+export { type A as AuthAccount, type a as AuthAdmin, type b as AuthAdminSession, type c as AuthAdminUser, type d as AuthCapabilities, type e as AuthConfigInfo, type f as AuthInvitation, type g as AuthJurisdiction, type h as AuthJurisdictionMove, type i as AuthMember, type j as AuthMoveResult, type k as AuthMoveTableReport, type l as AuthNamespaceLike, type m as AuthOrgRole, type n as AuthOrganization, type o as AuthPage, type p as AuthPasskey, type q as AuthSignUpInvitation, type r as AuthTeam, type s as AuthTeamMember, type t as AuthTimestamp, type u as AuthUserFieldSpec, type C as CreateAuthAdminOptions, D as DEFAULT_AUTH_BASE_PATH, type v as DoAuthWiring, type w as DoAuthWiringOptions, type I as ImpersonationResult, type L as ListUsersOptions, x as LunoraAuthAdminError, y as authDiscoveryPaths, z as authDiscoveryPathsFor, B as createAuthAdmin, E as createDoAuthWiring, F as handleAuthDiscoveryRequest, G as handleAuthRequest } from "./packem_shared/worker.d-B0mER8nz.mjs";
+import { AppendAuthAuditEntry, AppendAuthAuditOptions, AuthAuditEvent } from "./audit.mjs";
+export { AUTH_AUDIT_TABLE, type AuthAuditEntry, type AuthAuditOutcome, type AuthAuditReader, type ReadAuthAuditOptions, appendAuthAuditEntry, createAuthAuditReader, ensureAuthAuditTable, readAuthAuditLog } from "./audit.mjs";
+import { createAuthMiddleware } from 'better-auth/api';
+import { SqlExecutor } from "./sql-store.mjs";
+export { createSqlAuthStore, d1Executor } from "./sql-store.mjs";
+import { a as LunoraAuthOptions } from "./packem_shared/create-auth.d-D1CKOFWc.mjs";
+export { type L as LunoraAuth, c as createAuth, r as resolveAuthOptions } from "./packem_shared/create-auth.d-D1CKOFWc.mjs";
+import { BetterAuthOptions } from 'better-auth';
+import { EmailClassification, EmailGateConfig } from "./email-guard.mjs";
+export { type EmailClass, type EmailGateMiddlewareOptions, assertEmailAllowed, classifyEmail, emailGateMiddleware, loadEmailDomainLists } from "./email-guard.mjs";
+export { type I as InviteOnlyOptions, type a as IssuedSignUpInvitation, type S as SignUpInvitation, c as createSignUpInvitation, l as listSignUpInvitations, p as pruneSignUpInvitations, r as revokeSignUpInvitation } from "./packem_shared/invite-only.d-DKyHHkkQ.mjs";
 export { type LunoraAuthApiContext, LunoraAuthHeadersError, type WithAuthPluginsMiddleware, type WithAuthPluginsOptions, withAuthPlugins } from "./middleware.mjs";
 export { default as authTables } from "./schema.mjs";
-import { BetterAuthOptions } from 'better-auth';
-export { type SqlExecutor, createSqlAuthStore, d1Executor } from "./sql-store.mjs";
 export { type AuthQuery, type AuthRow, type AuthStore, type AuthWhereClause, createMemoryAuthStore, matchesWhere } from "./store.mjs";
 export { type FetchLike, TURNSTILE_VERIFY_ENDPOINT, type TurnstileVerifyResult, type VerifyTurnstileOptions, verifyTurnstile } from "./turnstile.mjs";
 export { type VerifyTurnstileMiddlewareOptions, verifyTurnstileMiddleware } from "./turnstile-middleware.mjs";
 import 'better-auth/adapters';
+import '@lunora/errors';
 import '@lunora/server';
-/**
-* A timestamp as it leaves the admin API: epoch-ms (better-auth stores `Date`s,
-* which we normalize on output) or `null` when the column is unset.
-*/
-type AuthTimestamp = null | number;
-/**
-* One user row as the admin API surfaces it. The fixed keys mirror better-auth's
-* core `user` table plus the `admin()` plugin columns (`role`/`banned`/…); the
-* index signature carries any app-defined `user.additionalFields` so callers
-* (the studio) can render them generically. Password material never lives on
-* this row (it's in the `account` table) and is never returned.
-*/
-interface AuthAdminUser {
-  [key: string]: unknown;
-  banExpires?: AuthTimestamp;
-  banned?: boolean | null;
-  banReason?: null | string;
-  createdAt?: AuthTimestamp;
-  email?: null | string;
-  emailVerified?: boolean | null;
-  id: string;
-  image?: null | string;
-  name?: null | string;
-  role?: null | string;
-  updatedAt?: AuthTimestamp;
+/** Configuration for {@link authAuditHook}. */
+interface AuthAuditHookConfig extends AppendAuthAuditOptions {
+  /**
+   * Where to persist the trail — the same {@link SqlExecutor} seam better-auth's
+   * store rides (`d1Executor(env.DB)`), so events land in the auth D1 database.
+   */
+  executor: SqlExecutor;
+  /**
+   * Optional export tap (pairs with SIEM forwarding): called with each redacted
+   * entry right after it is persisted, so a deployment can fan events out to an
+   * external sink. Rejections/throws are swallowed so forwarding can't break an
+   * auth request.
+   */
+  onRecord?: (entry: AppendAuthAuditEntry) => Promise<void> | void;
+  /**
+   * When true, `x-forwarded-for` is trusted as a client-IP fallback when
+   * `cf-connecting-ip` is absent — only enable this behind a proxy you control,
+   * or the recorded IP is attacker-chosen. Defaults to `false`: off Cloudflare,
+   * with no trusted proxy configured, the audit record's `ip` is omitted rather
+   * than populated from a spoofable header.
+   */
+  trustProxyHeaders?: boolean;
 }
 /**
-* One session row as the admin API surfaces it. Mirrors better-auth's `session`
-* table; `impersonatedBy` is set when the session was minted by
-* {@link AuthAdmin.impersonateUser}. The signing `token` is stripped — it's a
-* bearer credential, and the only place we hand one back is the explicit
-* impersonation flow.
-*/
-interface AuthAdminSession {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  expiresAt?: AuthTimestamp;
-  id: string;
-  impersonatedBy?: null | string;
-  ipAddress?: null | string;
-  userAgent?: null | string;
-  userId: string;
-}
-/** One linked account (a credential or OAuth provider). All token material is stripped. */
-interface AuthAccount {
-  [key: string]: unknown;
-  accountId?: null | string;
-  createdAt?: AuthTimestamp;
-  id: string;
-  providerId?: null | string;
-  scope?: null | string;
-  userId: string;
-}
-/** One organization row (from the `organization` plugin). */
-interface AuthOrganization {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  id: string;
-  name?: null | string;
-  slug?: null | string;
-}
-/** One organization membership row. */
-interface AuthMember {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  id: string;
-  organizationId: string;
-  role?: null | string;
-  userId: string;
-}
-/** One pending organization invitation. */
-interface AuthInvitation {
-  [key: string]: unknown;
-  email?: null | string;
-  expiresAt?: AuthTimestamp;
-  id: string;
-  organizationId: string;
-  role?: null | string;
-  status?: null | string;
-}
-/** One team row (from the `organization` plugin with `teams.enabled`). */
-interface AuthTeam {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  id: string;
-  name?: null | string;
-  organizationId: string;
-}
-/** One team-membership row (teams). */
-interface AuthTeamMember {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  id: string;
-  teamId: string;
-  userId: string;
+ * Structural view of the fields we read off better-auth's after-hook context —
+ * kept loose to avoid coupling to internal types.
+ *
+ * `body` is the parsed request body better-auth's middleware context exposes
+ * as `ctx.body` — pinned present and populated (e.g. `.email`) in the after-hook
+ * by `__tests__/audit-hooks.behaviour.test.ts` (plan 280 S0).
+ */
+interface AuditHookContext {
+  body?: Record<string, unknown>;
+  context?: {
+    newSession?: {
+      session?: {
+        userId?: string;
+      };
+      user?: {
+        email?: string;
+        id?: string;
+      };
+    } | null;
+    returned?: unknown;
+    session?: {
+      session?: {
+        userId?: string;
+      };
+      user?: {
+        email?: string;
+        id?: string;
+      };
+    } | null;
+  };
+  headers?: Headers;
+  path?: string;
+  request?: Request;
 }
 /**
-* One custom organization role (from the organization plugin's dynamic
-* access-control). `permission` is a JSON string of a `resource → actions[]` map
-* as stored; the studio parses it for display/editing.
-*/
-interface AuthOrgRole {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  id: string;
-  organizationId: string;
-  permission?: null | string;
-  role?: null | string;
-}
-/** One registered passkey. Credential secrets (`publicKey`) are stripped. */
-interface AuthPasskey {
-  [key: string]: unknown;
-  createdAt?: AuthTimestamp;
-  deviceType?: null | string;
-  id: string;
-  name?: null | string;
-  userId: string;
-}
-/** A page of rows plus the unpaginated total. */
-interface AuthPage<T> {
-  rows: T[];
-  total: number;
-}
+ * Map a better-auth endpoint path to the security event it represents, or
+ * `undefined` for endpoints not worth auditing (session reads, config, …). Match
+ * is by suffix so a caller `basePath` prefix (`/api/auth`) never affects it.
+ *
+ * Sign-in is split by what the endpoint actually DOES (plan 280 §4):
+ *
+ * - `/sign-in/social`, `/sign-in/magic-link` and `@better-auth/sso`'s
+ * `/sign-in/sso` only DISPATCH — the first mints a provider redirect URL, the
+ * second sends an email, the third answers `{ url, redirect: true }` pointing
+ * at the identity provider's authorization endpoint. Nobody is authenticated
+ * yet, so these are `sign-in-initiated`, not `sign-in`. Without the `sso`
+ * branch that path fell through to the `/sign-in/` substring below and every
+ * SSO redirect mint was recorded as a completed, successful `sign-in` with no
+ * actor — in exactly the flow where the "who authenticated" trail matters
+ * most.
+ * - `/callback/:id` (social + generic-oauth), `/magic-link/verify`,
+ * `@better-auth/sso`'s `/sso/saml2/sp/acs/:providerId`, and every
+ * `/two-factor/verify-*` (`verify-totp` / `verify-otp` / `verify-backup-code`
+ * — all three complete a challenged sign-in the same way) are where a
+ * session actually gets issued, so they join credential sign-ins
+ * (`/sign-in/email`, `/sign-in/username`, `/sign-in/phone-number`, …) as
+ * plain `sign-in`. They were NOT recorded at all before this change.
+ *
+ * The SAML assertion consumer service needs its own branch because it is the
+ * one completion that carries no `/callback/` segment: `processSAMLResponse`
+ * validates the assertion, resolves the user and calls `setSessionCookie`, all
+ * under `/sso/saml2/sp/acs/:providerId`. Matching neither that substring nor
+ * any other branch, it classified as `undefined` — the endpoint that issues
+ * every SAML session left no audit row at all.
+ *
+ * SAML sign-OUT has the mirror-image problem, and two endpoints rather than
+ * one. Neither ends in `/sign-out`, and both terminate the local session before
+ * redirecting, so both are `sign-out` rather than an initiated event:
+ *
+ * - `/sso/saml2/logout/:providerId` — SP-initiated. Deletes the SAML session
+ * keys, calls `deleteSession` on the current session token and
+ * `deleteSessionCookie`, then redirects to the IdP's logout URL.
+ * - `/sso/saml2/sp/slo/:providerId` — the SP's single-logout receiver, for the
+ * IdP-initiated direction and for the response leg of an SP-initiated one.
+ * Both `handleLogoutRequest` and `handleLogoutResponse` call `deleteSession`
+ * and `deleteSessionCookie` the same way.
+ *
+ * Recording the SAML sign-in while leaving these silent is worse than either
+ * gap alone: the trail would show a session opening and never closing, so a
+ * reader cannot tell "still signed in" from "we stopped watching".
+ *
+ * There is no dedicated `/oauth2/callback/*` branch because the generic
+ * `/callback/` check above already covers it, and covering it is CORRECT: an
+ * OAuth callback is a completed sign-in whatever path prefix it arrives on. The
+ * same substring also catches `@better-auth/sso`'s `/sso/callback/:providerId`,
+ * which is where an SSO sign-in actually completes — `sso` is re-exported from
+ * `@lunora/auth/plugins/enterprise`, so that path is live, not hypothetical.
+ *
+ * Checked against the installed `better-auth` and `@better-auth/*` dist for
+ * 1.7.3: generic-oauth registers NO endpoints of its own (there is no
+ * `/sign-in/oauth2`) — it registers providers used through the core
+ * `/sign-in/social` and `/callback/:id`, and the one dist hit for a literal
+ * `/oauth2/callback/` is inside `better-auth/plugins/oauth-popup`, which
+ * `plugins.ts` does not re-export — so today the branch fires for the core
+ * callback, and stays correct if the other becomes reachable.
+ */
+declare const eventForPath: (path: string) => AuthAuditEvent | undefined;
 /**
-* Which admin surfaces a given auth instance supports, derived from the enabled
-* better-auth plugins (and any {@link CreateAuthAdminOptions.features} overrides).
-* The studio calls {@link AuthAdmin.capabilities} once and renders only the
-* panels whose capability is `true` — so a deployment that doesn't enable, say,
-* the `organization` plugin never shows an Organizations section.
-*/
-interface AuthCapabilities {
-  /** Linked-account browsing/unlinking — core (the `account` table always exists). */
-  accounts: boolean;
-  /** The `admin()` plugin: ban/role/impersonate/create/delete/set-password. */
-  admin: boolean;
-  /** The `organization` plugin: orgs, members, invitations. */
-  organization: boolean;
-  /** The `@better-auth/passkey` plugin: per-user passkeys. */
-  passkey: boolean;
-  /** The `two-factor` plugin: per-user 2FA status / disable. */
-  twoFactor: boolean;
-}
+ * Build the entry a given after-hook context should record, or `undefined` when
+ * the path is not an audited security event. Exported for direct unit testing of
+ * the classification/extraction without spinning up better-auth.
+ *
+ * Does NOT attempt to distinguish a 2FA-challenged credential sign-in from a
+ * fully successful one (a `sign-in-challenged` event, as an earlier design for
+ * this change proposed) — pinned in `__tests__/audit-hooks.behaviour.test.ts`
+ * (plan 280 S0): better-auth runs the APP's own `hooks.after` BEFORE the
+ * `twoFactor` plugin's own after-hook that rewrites the response to
+ * `{ twoFactorRedirect: true }` and nulls `ctx.context.newSession`. By the time
+ * THIS hook runs, `context.returned`/`context.newSession` still reflect the
+ * pre-interception, fully-successful sign-in — there is nothing here to detect
+ * the challenge from. Distinguishing it would need a different seam (e.g. a
+ * plugin-ordered-after-`twoFactor` hook, or reading `twoFactor`'s own
+ * database state) and is left to a follow-up.
+ */
+declare const buildAuditEntry: (context: AuditHookContext, { now, trustProxyHeaders }?: {
+  now?: number;
+  trustProxyHeaders?: boolean;
+}) => AppendAuthAuditEntry | undefined;
 /**
-* One app/plugin-defined field the create-user form should render, derived from
-* the merged better-auth `user` table (core + plugin + `additionalFields`). Only
-* user-settable columns are surfaced — server-managed flags (`input: false`),
-* foreign keys (`references`), and the core columns the form already handles
-* (`email`/`name`/`role`/ban state/…) are filtered out upstream.
-*/
-interface AuthUserFieldSpec {
-  /** Logical field name (the key passed back in `createUser`'s `data`). */
-  name: string;
-  /** Best-effort plugin id the field originates from (`username`, `phone-number`, …); `undefined` for app `additionalFields`. */
-  plugin?: string;
-  required: boolean;
-  /** Coarse input kind the studio maps to a control (checkbox / number / date / text). */
-  type: "boolean" | "date" | "number" | "string";
-  unique: boolean;
-}
+ * Create the better-auth `hooks.after` middleware that records the auth/security
+ * audit trail. Assign it to `hooks.after` (or compose via {@link withAuthAudit}).
+ *
+ * ```ts
+ * const auth = createAuth({
+ *     secret: env.AUTH_SECRET,
+ *     database: lunoraD1Adapter(env.DB),
+ *     hooks: { after: authAuditHook({ executor: d1Executor(env.DB), retention: 100_000 }) },
+ * });
+ * ```
+ *
+ * ## Behaviour change (plan 280) — `onRecord`/SIEM consumers keyed on `event` strings, read this
+ *
+ * | Endpoint                                          | Before              | After                 |
+ * | -------------------------------------------------- | ------------------- | --------------------- |
+ * | `/sign-in/email` (and other credential sign-ins)  | `sign-in`           | `sign-in` (unchanged) |
+ * | `/sign-in/social`                                  | `sign-in`           | `sign-in-initiated`   |
+ * | `/sign-in/magic-link`                              | `sign-in`           | `sign-in-initiated`   |
+ * | `/callback/:id` (social + generic-oauth)          | _(not recorded)_    | `sign-in`             |
+ * | `/magic-link/verify`                               | _(not recorded)_    | `sign-in`             |
+ * | `/two-factor/verify-totp` / `-otp` / `-backup-code`| _(not recorded)_    | `sign-in`             |
+ *
+ * A caller matching on `event === "sign-in"` now sees FEWER events for
+ * `/sign-in/social` and `/sign-in/magic-link` (they never actually authenticated
+ * anyone) and MORE events for the four previously-unrecorded completion
+ * endpoints — the net effect is a more truthful count, not a strictly larger or
+ * smaller one. `sign-in-initiated` is a new event name (open `AuthAuditEvent`
+ * union, so no wire/type break, but SIEM rules enumerating event names should
+ * add it). A failed sign-in now also carries `targetEmail` (the attempted
+ * address/username) when the request body supplied one — see
+ * {@link AppendAuthAuditEntry.targetEmail} — so credential-stuffing attempts can
+ * be grouped by target even though they never produce an `actorEmail`.
+ *
+ * NOT changed: `/sign-in/email` under an active 2FA challenge still records
+ * plain `sign-in` / `success` (not a distinct `sign-in-challenged` event) — see
+ * {@link buildAuditEntry}'s docblock for why that distinction turned out not to
+ * be buildable from this hook.
+ */
+declare const authAuditHook: (config: AuthAuditHookConfig) => ReturnType<typeof createAuthMiddleware>;
 /**
-* A rich, read-only description of the deployment's auth configuration for the
-* studio's config panel and dynamic create-user form. Unlike
-* {@link AuthCapabilities} (five booleans that gate panels), this exposes *what*
-* is configured — enabled plugins, email/password + social sign-in, the
-* user-settable fields, organization sub-features (teams / custom roles), and
-* the session + rate-limit policy — without ever leaking a secret.
-*/
-interface AuthConfigInfo {
-  /** The same capability booleans {@link AuthAdmin.capabilities} returns, embedded so a single call drives the whole panel. */
-  capabilities: AuthCapabilities;
-  /** Whether email + password sign-in is enabled. */
-  emailAndPassword: boolean;
-  /** Organization plugin sub-features. */
-  organization: {
-    enabled: boolean; /** Custom roles / dynamic access control (`organizationRole` table present). */
-    roles: boolean;
-    /** Teams (`team` table present). */
-    teams: boolean;
-  };
-  /** Enabled better-auth plugin ids, sorted. */
-  plugins: string[];
-  /** Rate-limit policy (window is in seconds). */
-  rateLimit: {
-    enabled: boolean;
-    max?: number;
-    window?: number;
+ * Merge the audit `hooks.after` middleware into a better-auth options object,
+ * composing with any `hooks.after` the caller already set (theirs runs first,
+ * then the audit record). Returns a new options object.
+ */
+declare const withAuthAudit: <Options extends {
+  hooks?: {
+    after?: unknown;
   };
-  /** Session policy (all durations in seconds). */
-  session: {
-    cookieCache?: boolean;
-    expiresIn?: number;
-    freshAge?: number;
-    updateAge?: number;
-  };
-  /** Configured social/OAuth provider ids, sorted. */
-  socialProviders: string[];
-  /** User-settable extra fields for the create-user form (plugin + app `additionalFields`). */
-  userFields: AuthUserFieldSpec[];
-}
-/** A scalar value usable in an adapter `where` clause / filter. */
-type WhereValue = boolean | number | string;
-/** Filtering / paging options for {@link AuthAdmin.listUsers}. */
-interface ListUsersOptions {
-  /** Column to filter on with `=` (defaults to `email` when `filterValue` is set). */
-  filterField?: string;
-  /** Exact-match filter value. */
-  filterValue?: WhereValue;
-  limit?: number;
-  offset?: number;
-  /** Substring search value (matched with `contains`). */
-  search?: string;
-  /** Column the `search` substring matches against (default `email`). */
-  searchField?: string;
-  /** Column to order by (default `createdAt`). */
-  sortBy?: string;
-  sortDirection?: "asc" | "desc";
-}
-/** The result of {@link AuthAdmin.impersonateUser}: a fresh session token to act as the target user. */
-interface ImpersonationResult {
-  expiresAt: AuthTimestamp;
-  /** Bearer session token for the impersonated user. The caller is responsible for using it (e.g. setting the cookie). */
-  token: string;
-  user: AuthAdminUser;
-}
+}>(options: Options, config: AuthAuditHookConfig) => Options;
 /**
-* The full read + write surface the studio's auth dashboard drives, backed by
-* better-auth's tables. Returned by {@link createAuthAdmin}. The runtime accepts
-* a structurally-compatible object as its `authAdmin` option and exposes each
-* method behind an admin-token-gated endpoint. Methods whose backing plugin is
-* absent still exist (they're not conditionally omitted) but the studio gates
-* them on {@link AuthAdmin.capabilities}; calling one for an unconfigured plugin
-* surfaces the underlying adapter error.
-*/
-interface AuthAdmin {
-  /** Directly add an existing user as an org member (server-side, no invitation/acceptance). */
-  addMember: (input: {
-    organizationId: string;
-    role?: string;
-    userId: string;
-  }) => Promise<AuthMember>;
-  /** Add a user to a team. */
-  addTeamMember: (input: {
-    teamId: string;
-    userId: string;
-  }) => Promise<AuthTeamMember>;
-  banUser: (input: {
-    expiresInSeconds?: number;
-    reason?: string;
-    userId: string;
-  }) => Promise<AuthAdminUser>;
-  cancelInvitation: (input: {
-    invitationId: string;
-  }) => Promise<void>;
-  capabilities: () => Promise<AuthCapabilities>;
-  /** Rich, read-only description of the auth configuration (plugins, fields, session policy, …). */
-  config: () => Promise<AuthConfigInfo>;
-  /** Create an organization; optionally seed an `owner` member for `ownerId`. */
-  createOrganization: (input: {
-    logo?: string;
-    metadata?: Record<string, unknown>;
-    name: string;
-    ownerId?: string;
-    slug?: string;
-  }) => Promise<AuthOrganization>;
-  /** Create a custom org role with a permission grant (a `resource → actions[]` map). */
-  createOrgRole: (input: {
-    organizationId: string;
-    permission: Record<string, string[]>;
-    role: string;
-  }) => Promise<AuthOrgRole>;
-  /** Create a team under an organization. */
-  createTeam: (input: {
-    name: string;
-    organizationId: string;
-  }) => Promise<AuthTeam>;
-  createUser: (input: {
-    data?: Record<string, unknown>;
-    email: string;
-    name: string;
-    password?: string;
-    role?: string | string[];
-  }) => Promise<AuthAdminUser>;
-  /** Delete an organization and cascade-delete its members, invitations, teams, and custom roles. */
-  deleteOrganization: (input: {
-    organizationId: string;
-  }) => Promise<void>;
-  /** Delete a custom org role. */
-  deleteOrgRole: (input: {
-    roleId: string;
-  }) => Promise<void>;
-  deletePasskey: (input: {
-    passkeyId: string;
-  }) => Promise<void>;
-  disableTwoFactor: (input: {
-    userId: string;
-  }) => Promise<void>;
-  impersonateUser: (input: {
-    userId: string;
-  }) => Promise<ImpersonationResult>;
-  /** Create a pending email invitation to an org (no acceptance side effects). */
-  inviteMember: (input: {
-    email: string;
-    inviterId?: string;
-    organizationId: string;
-    role?: string;
-  }) => Promise<AuthInvitation>;
-  listAccounts: (input: {
-    userId: string;
-  }) => Promise<AuthAccount[]>;
-  listInvitations: (options: {
-    limit?: number;
-    offset?: number;
-    organizationId: string;
-  }) => Promise<AuthPage<AuthInvitation>>;
-  listMembers: (options: {
-    limit?: number;
-    offset?: number;
-    organizationId: string;
-  }) => Promise<AuthPage<AuthMember>>;
-  listOrganizations: (options: {
-    limit?: number;
-    offset?: number;
-  }) => Promise<AuthPage<AuthOrganization>>;
-  /** List an org's custom roles. */
-  listOrgRoles: (options: {
-    limit?: number;
-    offset?: number;
-    organizationId: string;
-  }) => Promise<AuthPage<AuthOrgRole>>;
-  listPasskeys: (input: {
-    userId: string;
-  }) => Promise<AuthPasskey[]>;
-  listSessions: (options: {
-    limit?: number;
-    offset?: number;
-    userId?: string;
-  }) => Promise<AuthPage<AuthAdminSession>>;
-  /** List a team's members. */
-  listTeamMembers: (options: {
-    limit?: number;
-    offset?: number;
-    teamId: string;
-  }) => Promise<AuthPage<AuthTeamMember>>;
-  /** List an org's teams. */
-  listTeams: (options: {
-    limit?: number;
-    offset?: number;
-    organizationId: string;
-  }) => Promise<AuthPage<AuthTeam>>;
-  listUsers: (options: ListUsersOptions) => Promise<AuthPage<AuthAdminUser>>;
-  removeMember: (input: {
-    memberId: string;
-  }) => Promise<void>;
-  /** Delete a team and its memberships. */
-  removeTeam: (input: {
-    teamId: string;
-  }) => Promise<void>;
-  /** Remove a member from a team. */
-  removeTeamMember: (input: {
-    teamMemberId: string;
-  }) => Promise<void>;
-  removeUser: (input: {
-    userId: string;
-  }) => Promise<void>;
-  revokeUserSession: (input: {
-    sessionId: string;
-  }) => Promise<void>;
-  revokeUserSessions: (input: {
-    userId: string;
-  }) => Promise<void>;
-  setRole: (input: {
-    role: string | string[];
-    userId: string;
-  }) => Promise<AuthAdminUser>;
-  setUserPassword: (input: {
-    newPassword: string;
-    userId: string;
-  }) => Promise<void>;
-  unbanUser: (input: {
-    userId: string;
-  }) => Promise<AuthAdminUser>;
-  unlinkAccount: (input: {
-    accountId: string;
-    userId: string;
-  }) => Promise<void>;
-  /** Change a member's role. */
-  updateMemberRole: (input: {
-    memberId: string;
-    role: string | string[];
-  }) => Promise<AuthMember>;
-  /** Update an organization's name/slug/logo/metadata. */
-  updateOrganization: (input: {
-    logo?: string;
-    metadata?: Record<string, unknown>;
-    name?: string;
-    organizationId: string;
-    slug?: string;
-  }) => Promise<AuthOrganization>;
-  /** Replace a custom org role's permission grant. */
-  updateOrgRole: (input: {
-    permission: Record<string, string[]>;
-    roleId: string;
-  }) => Promise<AuthOrgRole>;
-  /** Rename a team. */
-  updateTeam: (input: {
-    name: string;
-    teamId: string;
-  }) => Promise<AuthTeam>;
-  updateUser: (input: {
-    data: Record<string, unknown>;
-    userId: string;
-  }) => Promise<AuthAdminUser>;
+ * The Durable Object state slice this class needs — structural so unit tests can
+ * pass a double without depending on the workers runtime.
+ */
+interface AuthDoState {
+  storage: DoStorageLike;
 }
-/** Options for {@link createAuthAdmin}. */
-interface CreateAuthAdminOptions {
+/** Path the worker calls to resolve a request's identity. Not part of `/api/auth/*`. */
+declare const RESOLVE_SESSION_PATH = "/__lunora/auth/session";
+/**
+ * Path the worker calls to read the audit log. Also not part of `/api/auth/*`.
+ *
+ * The audit table lives in this object like every other auth table, so the worker
+ * cannot query it directly — same constraint as the session route, same shared secret.
+ */
+declare const READ_AUDIT_PATH = "/__lunora/auth/audit";
+/** Header carrying the shared secret that authenticates the calling worker. */
+declare const INTERNAL_SECRET_HEADER = "x-lunora-auth-do-secret";
+/**
+ * Options for the auth DO, beyond the better-auth options themselves.
+ */
+interface AuthDoOptions {
   /**
-  * Force individual {@link AuthCapabilities} on or off regardless of which
-  * plugins are detected — e.g. `{ impersonate: false }`-style opt-outs by
-  * setting `admin: false`, or hiding linked accounts with `accounts: false`.
-  * A capability is reported only when both its plugin is enabled *and* its
-  * override isn't `false`.
-  */
-  features?: Partial<AuthCapabilities>;
+   * Shared secret authenticating the worker on {@link RESOLVE_SESSION_PATH}.
+   *
+   * The DO binding is reachable from any worker bound to the namespace, so the
+   * binding alone is not an authorization boundary — same reasoning as
+   * `SessionDO`'s `SESSION_DO_SECRET`. When this is unset the internal route is
+   * refused outright rather than served unauthenticated: a missing secret is a
+   * misconfiguration, and answering identity questions to anyone is the one
+   * failure mode worth being loud about. `/api/auth/*` is unaffected — those
+   * routes carry their own credentials.
+   */
+  internalSecret?: string;
+}
+/**
+ * Base class for an app's auth Durable Object. Subclass it (or let codegen emit the
+ * subclass) and register the subclass in `wrangler.jsonc`.
+ *
+ * ```ts
+ * export class AuthDO extends LunoraAuthDO {
+ *     public constructor(state: DurableObjectState, env: Env) {
+ *         super(state, () => ({ secret: env.AUTH_SECRET, plugins: [scim({ … })] }), {
+ *             internalSecret: env.AUTH_DO_SECRET,
+ *         });
+ *     }
+ * }
+ * ```
+ */
+declare class LunoraAuthDO {
+  #private;
   /**
-  * User id recorded as the impersonator on sessions minted by
-  * {@link AuthAdmin.impersonateUser}. Defaults to the impersonated user's own
-  * id (a self-reference) since the trusted admin plane has no acting user.
-  */
-  impersonatedBy?: string;
+   * @param state The Durable Object state — its `storage` becomes better-auth's database.
+   * @param optionsFactory Builds the better-auth options. Called once, lazily, on the first request.
+   * @param options Auth-DO specific options (base path, internal secret).
+   */
+  constructor(state: AuthDoState, optionsFactory: () => LunoraAuthOptions, options?: AuthDoOptions);
   /**
-  * How long (in seconds) an impersonation session lives. Must be a positive
-  * finite integer. Capped at 24 × {@link DEFAULT_IMPERSONATION_SECONDS}
-  * (86 400 s / 24 h). Defaults to {@link DEFAULT_IMPERSONATION_SECONDS}
-  * (3 600 s / 1 h).
-  */
-  impersonationSeconds?: number;
+   * Serve an auth request. Routes under `/api/auth` go to better-auth, and so do
+   * the OAuth discovery documents its options configure (`./discovery`); the
+   * internal session route is handled here; anything else is a 404.
+   *
+   * The base path is not configurable. The worker half only ever forwards
+   * `/api/auth/*` (`createDoAuthWiring`, which codegen calls with no base path),
+   * so a second knob here could only ever disagree with it.
+   */
+  fetch(request: Request): Promise<Response>;
 }
 /**
-* A normalized failure from an admin operation. better-auth throws `APIError`s
-* carrying a `body.code` (e.g. `USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL`); we
-* surface that `code` so the runtime can map it onto an HTTP status and the
-* studio can show a meaningful message instead of a generic 500.
-*/
-declare class LunoraAuthAdminError extends LunoraError {
-  constructor(message: string, code: string);
-}
+ * The `CREATE TABLE` / `CREATE INDEX` statements for a better-auth config, in
+ * execution order (every table before any index).
+ *
+ * All statements are `IF NOT EXISTS`, so this is safe to run on every cold start —
+ * which is how `LunoraAuthDO` uses it. It creates; it never alters or drops, so a
+ * schema that has already diverged is left alone rather than half-migrated.
+ *
+ * Physical names throughout: `modelName` for tables, `fieldName ?? key` for columns,
+ * and better-auth's own resolved `columns` / `name` for indexes — so an index name
+ * here is the name better-auth's introspection expects to find.
+ * @param options The better-auth options the DO will run — the plugin list decides which tables exist.
+ * @returns SQL statements to execute in order.
+ */
+declare const authDoSchemaStatements: (options: LunoraAuthOptions) => string[];
 /**
-* Build the studio's auth user-management plane on top of better-auth.
-*
-* Pass the result as the runtime's `authAdmin` option; the runtime exposes each
-* method behind an admin-token-gated `/_lunora/admin/auth/*` endpoint. The set
-* of usable surfaces is reported by {@link AuthAdmin.capabilities} — derived
-* from the enabled better-auth plugins, so enabling `admin()`, `organization()`,
-* `twoFactor()`, or the passkey plugin in the auth config is what lights up the
-* matching dashboard panels.
-*
-* **Trust model — important.** These operations talk to better-auth's
-* `internalAdapter` (and `adapter`/password hasher) **directly**, deliberately
-* bypassing the plugins' own endpoints, which require the caller to hold an
-* admin-role session. That session check is the wrong gate here: the runtime
-* already authorizes every call with `LUNORA_ADMIN_TOKEN`, so this helper acts
-* as a trusted server-side operator. It is therefore not an end-user-callable
-* API — never expose it on a path that isn't admin-token gated.
-*
-* `auth.$context` is a promise (better-auth resolves the adapter, password
-* config, etc. lazily); we memoize it so the first call pays the cost once.
-*/
-declare const createAuthAdmin: (auth: LunoraAuth, options?: CreateAuthAdminOptions) => AuthAdmin;
+ * `ALTER TABLE … ADD COLUMN` statements for columns the live schema is missing.
+ *
+ * ## Why this is needed at all
+ *
+ * {@link authDoSchemaStatements} is entirely `IF NOT EXISTS`, which makes it safe to
+ * re-run but blind to change: a *new table* appears on the next cold start, a *new
+ * column on an existing table* never does. That is not a hypothetical — enabling the
+ * `admin` plugin after first deploy adds `role` / `banned` / `banExpires` to `user`,
+ * and without this the object would keep serving a `user` table that cannot hold them.
+ *
+ * Additive only. Nothing here drops, renames, or retypes a column: a column that
+ * exists is left exactly as it is, so a schema someone has deliberately diverged is
+ * never "corrected" underneath them.
+ *
+ * ## What SQLite will not let us do
+ *
+ * `ADD COLUMN` cannot introduce a `NOT NULL` column without a default (existing rows
+ * would violate it immediately), and cannot introduce `UNIQUE`. So a required column
+ * with a static default is added with both; a required column *without* one is added
+ * **nullable**, which differs from what a fresh `CREATE TABLE` would produce. That is
+ * the deliberate trade: better-auth writes these fields on every insert, so nullable
+ * is harmless, whereas refusing to add the column at all would leave the object
+ * broken. Uniqueness is unaffected — better-auth expresses it as a separate index, and
+ * those are `IF NOT EXISTS`, so they are created by the statements above.
+ * @param options The better-auth options the DO runs, already resolved.
+ * @param existingColumns Physical column names currently present on a table; empty/absent for a table that does not exist yet (it will be created instead).
+ * @returns SQL statements to execute in order; empty when the live schema is current.
+ */
+declare const authDoColumnAdditions: (options: LunoraAuthOptions, existingColumns: (table: string) => Iterable<string>) => string[];
+/** better-auth's `databaseHooks` shape, derived so a rename upstream fails to compile rather than silently mis-hooking. */
+type DatabaseHooks = NonNullable<BetterAuthOptions["databaseHooks"]>;
+/** Config for the signup gate hooks: the base {@link EmailGateConfig} plus an optional classification tap. */
+interface EmailGateHookConfig extends EmailGateConfig {
+  /**
+   * Called with the resolved classification once the gate passes, so app policy
+   * can react to `free` vs `business` at signup (e.g. tag the account). Never
+   * fires when the gate rejects. `context` is better-auth's endpoint context
+   * (`null` outside a request, e.g. an internal create).
+   */
+  onClassify?: (classification: EmailClassification, user: Record<string, unknown>, context: unknown) => void;
+}
 /**
-* Default basePath used by better-auth's client + handler. Override via the
-* second argument if you mount the auth routes somewhere else.
-*/
-declare const DEFAULT_AUTH_BASE_PATH: string;
+ * Produce a `databaseHooks` fragment that gates better-auth's native signup on
+ * the email-domain policy. Spread it into `createAuth({ databaseHooks: … })`, or
+ * use {@link withEmailGate} to merge it (composing with any existing
+ * `user.create.before`).
+ *
+ * ```ts
+ * const auth = createAuth({
+ *     secret: env.AUTH_SECRET,
+ *     database: lunoraD1Adapter(env.DB),
+ *     databaseHooks: emailGateDatabaseHooks({ blockDisposable: true }),
+ * });
+ * ```
+ */
+declare const emailGateDatabaseHooks: (config?: EmailGateHookConfig) => DatabaseHooks;
 /**
-* Route an inbound `Request` to better-auth if the path falls under
-* `basePath`; otherwise return `null` so the caller can continue dispatching.
-*
-* Better-auth handles arbitrarily nested paths (`/api/auth/sign-in/email`,
-* `/api/auth/callback/github`, …), so we use prefix matching instead of the
-* exact-path map `createWorker` consumes for top-level routes.
-*/
-declare const handleAuthRequest: (auth: LunoraAuth, request: Request, basePath?: string) => Promise<Response | undefined>;
+ * Merge the email-domain signup gate into an existing better-auth options object,
+ * preserving any `databaseHooks` the caller already set. If they already declared
+ * a `user.create.before`, the gate runs first (rejecting disposable signups
+ * before their hook sees them), then theirs runs on the (possibly rewritten) user.
+ *
+ * ```ts
+ * const auth = createAuth(withEmailGate({ secret, database }, { blockDisposable: true }));
+ * ```
+ */
+declare const withEmailGate: (options: BetterAuthOptions, config?: EmailGateHookConfig) => BetterAuthOptions;
 /**
-* Apply better-auth's required schema (`user`, `session`, `account`,
-* `verification`) to the configured database. Idempotent — better-auth
-* diffs the existing schema and only runs the missing DDL.
-*
-* Cached per `options` reference so the diff cost (one PRAGMA-style sweep
-* per table) doesn't fire on every request. In Cloudflare Workers the same
-* `env.DB` binding is reused across invocations within a single isolate, so
-* caching against the options object — which captures the binding — is
-* sufficient.
-*
-* For production you should prefer pre-applying the schema at deploy time
-* via `compileMigrationsSql` + `wrangler d1 execute`; this helper exists for
-* dev/playground and small deployments.
-*/
-declare const ensureMigrated: (auth: LunoraAuth | {
-  options: LunoraAuthOptions;
-}) => Promise<void>;
+ * Whether the Worker is running in development: at least one of `CF_ENV`,
+ * `ENVIRONMENT`, `NODE_ENV` or `WORKER_ENV` is set, and EVERY one that is set
+ * names a dev environment. A set-but-empty var counts as set, so it vetoes dev.
+ * `@lunora/mail`, `@lunora/queue` and `@lunora/shard-engine` still treat an empty
+ * var as unset; this copy is stricter on purpose.
+ *
+ * `every`, not `some`: a production deploy that also carries a leftover dev
+ * `NODE_ENV` must stay production, or it would log auth links (bearer
+ * credentials) and run migrations on cold start. A deploy that sets none of the
+ * vars is production too — fail closed either way.
+ */
+declare const isDevEnvironment: (env: Record<string, unknown>) => boolean;
 /**
-* Compile better-auth's migrations to a single SQL string. Useful for
-* `wrangler d1 execute --file -` in CI so the deploy step applies the schema
-* before the first user request.
-*
-* Compiles from the SAME resolved options `createAuth` runs with (via
-* `resolveAuthOptions`), not the raw caller options — so the schema includes the
-* `rateLimit` table the worker's default-on durable limiter writes to. Compiling
-* from the raw options would omit it, and the running worker would then write to
-* a table the migration never created.
-*/
-declare const compileMigrationsSql: (options: LunoraAuthOptions) => Promise<string>;
+ * The cleanup statements, in execution order: every blocking index, then the column.
+ *
+ * Exported for the pre-applied-schema path (`compileMigrationsSql` + `wrangler d1 execute`),
+ * which compiles DDL without ever reading the database and so can neither tell whether the
+ * column is present nor discover the index names — SQLite has no `DROP COLUMN IF EXISTS` to
+ * make either unnecessary. Pass the names from
+ * `SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = 'account'`, and
+ * run this only against a database that still has the column.
+ * @param accountTable Physical name of the account table (`account` unless renamed via `account.modelName`).
+ * @param indexNames Indexes to drop first, from {@link indexesReferencingIssuer}.
+ * @returns The `DROP INDEX` statements followed by the `DROP COLUMN`.
+ */
+declare const legacyIssuerCleanupStatements: (accountTable?: string, indexNames?: Iterable<string>) => string[];
 /**
-* Lunora-friendly view over better-auth's `session` option.
-*
-* This is a typed alias for better-auth's own `session` shape — Lunora stays a
-* thin wrapper, so we don't reimplement the fields, we just give them a named,
-* documented home so callers get autocomplete without reaching into
-* `BetterAuthOptions`. The most relevant fields for session rotation / richer
-* policies are `expiresIn` (absolute session lifetime, in seconds),
-* `updateAge` (rolling-rotation interval, in seconds — how often an active
-* session's expiry is pushed forward; `0` rotates on every use),
-* `disableSessionRefresh` (turn rolling rotation off entirely so sessions
-* expire at the absolute `expiresIn` regardless of activity), `freshAge`
-* (freshness window, in seconds, for sensitive operations like account
-* deletion; `0` treats every session as fresh — not recommended), and
-* `cookieCache` (opt-in signed-cookie session cache to skip DB reads).
-*
-* See better-auth's `session` option for the full field list.
-*/
+ * Lunora-friendly view over better-auth's `session` option.
+ *
+ * This is a typed alias for better-auth's own `session` shape — Lunora stays a
+ * thin wrapper, so we don't reimplement the fields, we just give them a named,
+ * documented home so callers get autocomplete without reaching into
+ * `BetterAuthOptions`. The most relevant fields for session rotation / richer
+ * policies are `expiresIn` (absolute session lifetime, in seconds),
+ * `updateAge` (rolling-rotation interval, in seconds — how often an active
+ * session's expiry is pushed forward; `0` rotates on every use),
+ * `disableSessionRefresh` (turn rolling rotation off entirely so sessions
+ * expire at the absolute `expiresIn` regardless of activity), `freshAge`
+ * (freshness window, in seconds, for sensitive operations like account
+ * deletion; `0` treats every session as fresh — not recommended), and
+ * `cookieCache` (signed-cookie session cache that skips DB reads —
+ * `createAuth` fills `{ enabled: true, maxAge: 60 }` when you leave it unset, so
+ * a revoked session keeps authenticating for up to that many seconds; pass
+ * `{ enabled: false }` where that window is unacceptable).
+ *
+ * See better-auth's `session` option for the full field list.
+ */
 type SessionPolicy = NonNullable<BetterAuthOptions["session"]>;
 /**
-* Validate a {@link SessionPolicy} and return it unchanged (pass-through).
-*
-* better-auth happily accepts the `session` block verbatim, so the only job
-* here is to catch obviously-broken numeric inputs at construction time —
-* negative or non-finite durations — rather than letting them produce
-* surprising cookie expiries at runtime. Field names mirror better-auth's
-* `session` option exactly so the validated object forwards 1:1.
-*/
+ * Validate a {@link SessionPolicy} and return it unchanged (pass-through).
+ *
+ * better-auth happily accepts the `session` block verbatim, so the only job
+ * here is to catch obviously-broken numeric inputs at construction time —
+ * negative or non-finite durations — rather than letting them produce
+ * surprising cookie expiries at runtime. Field names mirror better-auth's
+ * `session` option exactly so the validated object forwards 1:1.
+ */
 declare const validateSessionPolicy: (policy: SessionPolicy) => SessionPolicy;
 /**
-* Ready-made {@link SessionPolicy} presets covering the common rotation /
-* expiry trade-offs. Spread or override fields as needed:
-*
-* ```ts
-* import { createAuth, sessionPresets } from "@lunora/auth";
-*
-* export const auth = createAuth({
-*     secret: env.AUTH_SECRET,
-*     database: env.DB,
-*     session: { ...sessionPresets.rolling, freshAge: 60 * 5 },
-* });
-* ```
-*
-* - `rolling` — balanced default: 7-day absolute expiry, rotated once per day,
-*   with a 60s signed-cookie session cache so bursts of authenticated calls
-*   skip the per-request DB session read.
-* - `strict` — short, security-sensitive: 1-hour expiry, 15-minute rotation,
-*   cookie cache **off** (fast revocation / short freshness is the whole point).
-* - `longLived` — low-friction consumer apps: 30-day expiry, daily rotation,
-*   with the same 60s cookie cache as `rolling`.
-*/
+ * Ready-made {@link SessionPolicy} presets covering the common rotation /
+ * expiry trade-offs. Spread or override fields as needed:
+ *
+ * ```ts
+ * import { createAuth, sessionPresets } from "@lunora/auth";
+ *
+ * export const auth = createAuth({
+ *     secret: env.AUTH_SECRET,
+ *     database: env.DB,
+ *     session: { ...sessionPresets.rolling, freshAge: 60 * 5 },
+ * });
+ * ```
+ *
+ * - `rolling` — balanced default: 7-day absolute expiry, rotated once per day,
+ *   with a 60s signed-cookie session cache so bursts of authenticated calls
+ *   skip the per-request DB session read.
+ * - `strict` — short, security-sensitive: 1-hour expiry, 15-minute rotation,
+ *   cookie cache **off** (fast revocation / short freshness is the whole point).
+ * - `longLived` — low-friction consumer apps: 30-day expiry, daily rotation,
+ *   with the same 60s cookie cache as `rolling`.
+ */
 declare const sessionPresets: Record<"longLived" | "rolling" | "strict", SessionPolicy>;
-export { type AuthAccount, type AuthAdmin, type AuthAdminSession, type AuthAdminUser, type AuthCapabilities, type AuthInvitation, type AuthMember, type AuthOrganization, type AuthPage, type AuthPasskey, type AuthTimestamp, type CreateAuthAdminOptions, DEFAULT_AUTH_BASE_PATH, type ImpersonationResult, type ListUsersOptions, type LunoraAuth, LunoraAuthAdminError, type LunoraAuthOptions, type SessionPolicy, compileMigrationsSql, createAuthAdmin, ensureMigrated, handleAuthRequest, sessionPresets, validateSessionPolicy };
+export { READ_AUDIT_PATH as AUTH_DO_AUDIT_PATH, INTERNAL_SECRET_HEADER as AUTH_DO_SECRET_HEADER, RESOLVE_SESSION_PATH as AUTH_DO_SESSION_PATH, type AppendAuthAuditEntry, type AppendAuthAuditOptions, type AuthAuditEvent, type AuthAuditHookConfig, type AuthDoOptions, type AuthDoState, type EmailClassification, type EmailGateConfig, type EmailGateHookConfig, LunoraAuthDO, type LunoraAuthOptions, type SessionPolicy, type SqlExecutor, authAuditHook, authDoColumnAdditions, authDoSchemaStatements, buildAuditEntry, emailGateDatabaseHooks, eventForPath, isDevEnvironment, legacyIssuerCleanupStatements, sessionPresets, validateSessionPolicy, withAuthAudit, withEmailGate };