@dbx-tools/tunnel 0.6.89 → 0.6.91

package/lib/src/plugin.js

@@ -1,12 +1,11 @@
 /**
- * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.
+ * `authGate()` - the AppKit adapter around `@dbx-tools/auth`.
  *
  * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the
  * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin
- * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed
- * one-time-code store, and the session JWT. `createApp` (with no `server()`) is
- * used only to auto-init `CacheManager` + prime the sibling `email` transport;
- * this plugin is where the gate logic lives.
+ * owns tunnel authorization, AppKit Lakebase discovery, email delivery, and
+ * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and
+ * passkeys. `createApp` can run this plugin with or without `server()`.
  *
  * Options come from CLI flags OR env, with sensible defaults - see
  * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't
@@ -15,14 +14,14 @@
  *
  * @module
  */
-import { Plugin, toPlugin } from "@databricks/appkit";
+import { lakebase, Plugin, toPlugin, ResourceType, } from "@databricks/appkit";
+import { plugin as appkitPlugin } from "@dbx-tools/appkit";
+import { auth as passwordlessAuth, storage as authStorage, } from "@dbx-tools/auth";
 import { config as coreConfig } from "@dbx-tools/core";
-import { brand, log, object, string } from "@dbx-tools/shared-core";
+import { brand, log, string } from "@dbx-tools/shared-core";
 import { TUNNEL_CONFIG } from "./_config.js";
 import { looksLikeEmail, matchesAllowlist } from "./allowlist.js";
 import { mountGate } from "./gate.js";
-import { CodeStore, signSession, verifySession } from "./otp.js";
-import { RateLimiter } from "./rate-limit.js";
 import { ensureEmailAvailable, sendCode as defaultSendCode } from "./send-code.js";
 import { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from "./signing-key.js";
 const logger = log.logger("tunnel:auth");
@@ -60,6 +59,11 @@ const DEFAULTS = {
 };
 /** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */
 export function resolveAuthGateConfig(config) {
+    const storage = authStorage.resolveAuthStorageConfig({
+        storage: config.storage ??
+            coreConfig.text("AUTH_STORAGE", TUNNEL_CONFIG),
+        sqlitePath: config.sqlitePath ?? coreConfig.text("AUTH_SQLITE_PATH", TUNNEL_CONFIG),
+    });
     return {
         // Both sources are unioned rather than one overriding: a deployment-wide
         // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.
@@ -82,10 +86,12 @@ export function resolveAuthGateConfig(config) {
             ...string.parseList(coreConfig.text("FORWARD_HEADERS", TUNNEL_CONFIG)),
         ],
         insecure: coreConfig.boolean(config.insecure, "INSECURE", TUNNEL_CONFIG) ?? false,
+        storage: storage.mode,
+        sqlitePath: storage.sqlitePath,
     };
 }
 /**
- * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login
+ * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login
  * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express
  * server via `this.context`, so a public portr caller must prove an email before
  * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and
@@ -95,27 +101,69 @@ export class AuthGatePlugin extends Plugin {
     static manifest = {
         name: "authGate",
         displayName: "Auth Gate",
-        description: "Email one-time-password access gate for a public tunnel.",
+        description: "Better Auth email OTP and passkey access gate for a public tunnel.",
         stability: "beta",
-        resources: { required: [], optional: [] },
+        resources: {
+            required: [],
+            optional: [
+                {
+                    type: ResourceType.POSTGRES,
+                    alias: "auth",
+                    resourceKey: "auth-database",
+                    description: "Durable users, sessions, OTP records, and passkeys.",
+                    permission: "CAN_CONNECT_AND_CREATE",
+                    fields: {
+                        instance_name: { env: "LAKEBASE_INSTANCE_NAME" },
+                        database_name: { env: "PGDATABASE" },
+                    },
+                },
+            ],
+        },
     };
     resolved;
-    codes;
-    // Requesting a code is email-spam-prone; verifying is a brute-force surface.
-    // Per-email AND per-IP so neither axis alone is a bypass.
-    requestLimiter = new RateLimiter(5, 15 * 60 * 1000);
-    verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);
+    runtime;
+    static getResourceRequirements(config) {
+        if (authStorage.resolveAuthStorageConfig(config).mode !== "lakebase")
+            return [];
+        return [
+            {
+                type: ResourceType.POSTGRES,
+                alias: "auth",
+                resourceKey: "auth-database",
+                description: "Durable users, sessions, OTP records, and passkeys.",
+                permission: "CAN_CONNECT_AND_CREATE",
+                fields: {
+                    instance_name: { env: "LAKEBASE_INSTANCE_NAME" },
+                    database_name: { env: "PGDATABASE" },
+                },
+                required: true,
+            },
+        ];
+    }
     async setup() {
         this.resolved = resolveAuthGateConfig(this.config);
-        this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);
-        // Resolve the signing key HERE rather than lazily on the first sign-in, so a
-        // cache that cannot hold it (and the resulting "sessions won't survive a
-        // restart" warning) shows up in the startup log, not hours later.
-        const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);
         if (this.resolved.insecure) {
-            logger.warn("insecure mode - the tunnel runs OPEN with no email-OTP gate");
+            logger.warn("insecure mode - the tunnel runs OPEN with no auth gate");
         }
         else {
+            const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);
+            const storage = await authStorage.createAuthStorage(this.resolved, lakebasePlugin?.exports().pool);
+            const { key } = await signingKey(this.resolved.sessionCutoffMs);
+            this.runtime = await passwordlessAuth.createPasswordlessAuth({
+                storage,
+                baseURL: authOrigin(this.resolved.publicDomain),
+                basePath: "/api/email/auth",
+                appName: this.resolved.brandName,
+                secret: Buffer.from(key).toString("base64url"),
+                sessionTtlSeconds: this.resolved.sessionTtlSeconds,
+                sessionCutoffMs: this.resolved.sessionCutoffMs,
+                codeTtlSeconds: this.resolved.codeTtlSeconds,
+                maxAttempts: this.resolved.maxAttempts,
+                authorizeIdentity: (email) => this.authorizeIdentity(email),
+                sendCode: (email, code, options) => this.sendCode(email, code, options),
+                subject: this.resolved.subject,
+                message: this.resolved.message,
+            });
             // `server()` is deferred, so it does not exist during this plugin's setup.
             // At `setup:complete` the Express app exists but has not injected plugin
             // routes or static handling yet, which is the one point the gate can mount
@@ -124,7 +172,8 @@ export class AuthGatePlugin extends Plugin {
                 this.mountGateRoutes();
                 // Fail fast once the sibling email plugin has primed its transport: a
                 // gate that cannot email a code lets nobody in.
-                await ensureEmailAvailable();
+                if (!this.config.sendCode)
+                    await ensureEmailAvailable();
             });
         }
         logger.info("ready", {
@@ -132,9 +181,15 @@ export class AuthGatePlugin extends Plugin {
             sessionTtlSeconds: this.resolved.sessionTtlSeconds,
             publicDomain: this.resolved.publicDomain ?? null,
             insecure: this.resolved.insecure,
-            ...object.optional("sessionCutoff", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),
+            storage: this.resolved.storage,
+            sessionCutoff: this.resolved.sessionCutoffMs > 0
+                ? new Date(this.resolved.sessionCutoffMs).toISOString()
+                : null,
         });
     }
+    async shutdown() {
+        await this.runtime?.close();
+    }
     /**
      * Register the login routes (`/api/email/auth/*`) and the gating middleware on
      * the app's OWN Express server. At `setup:complete`, the deferred server plugin
@@ -145,7 +200,7 @@ export class AuthGatePlugin extends Plugin {
     mountGateRoutes() {
         const context = this.context;
         if (!context) {
-            logger.warn("no plugin context - the OTP gate cannot mount its routes");
+            logger.warn("no plugin context - the auth gate cannot mount its routes");
             return;
         }
         mountGateOnContext(context, {
@@ -158,56 +213,33 @@ export class AuthGatePlugin extends Plugin {
     get sendCode() {
         return this.config.sendCode ?? defaultSendCode;
     }
+    authorizeIdentity(email) {
+        if (this.config.authorizeIdentity)
+            return this.config.authorizeIdentity(email);
+        return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);
+    }
     exports() {
+        const runtime = this.runtime;
         return {
-            sessionTtlSeconds: this.resolved.sessionTtlSeconds,
-            request: (email, ip) => this.handleRequest(email, ip),
-            verify: (email, code, ip) => this.handleVerify(email, code, ip),
-            session: (token) => verifySession(token),
-            status: async (token) => ({
-                authenticated: Boolean(await verifySession(token)),
-                email: (await verifySession(token)) ?? undefined,
-                enabled: true,
-            }),
+            passkeysEnabled: runtime?.passkeysEnabled ?? false,
+            handler: (request) => runtime?.handler(request) ?? Promise.resolve(new Response("Not Found", { status: 404 })),
+            session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),
+            status: (headers) => runtime?.status(headers) ??
+                Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),
+            close: () => runtime?.close() ?? Promise.resolve(),
         };
     }
-    async handleRequest(email, ip) {
-        const address = email.trim().toLowerCase();
-        const byIp = this.requestLimiter.hit(`ip:${ip}`);
-        const byEmail = this.requestLimiter.hit(`email:${address}`);
-        if (!byIp.allowed || !byEmail.allowed) {
-            return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
-        }
-        if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {
-            const code = await this.codes.issue(address);
-            try {
-                await this.sendCode(address, code, {
-                    subject: this.resolved.subject,
-                    brandName: this.resolved.brandName,
-                    message: this.resolved.message,
-                    codeTtlSeconds: this.resolved.codeTtlSeconds,
-                });
-            }
-            catch (error) {
-                logger.warn("failed to send OTP email", { error });
-            }
-        }
-        return { ok: true };
-    }
-    async handleVerify(email, code, ip) {
-        const address = email.trim().toLowerCase();
-        const byIp = this.verifyLimiter.hit(`ip:${ip}`);
-        const byEmail = this.verifyLimiter.hit(`email:${address}`);
-        if (!byIp.allowed || !byEmail.allowed) {
-            return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };
-        }
-        if ((await this.codes.verify(address, code.trim())) !== "ok")
-            return { ok: false };
-        this.requestLimiter.reset(`email:${address}`);
-        this.verifyLimiter.reset(`email:${address}`);
-        return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };
-    }
+}
+function authOrigin(publicDomain) {
+    const value = string.trimToNull(publicDomain);
+    if (!value)
+        return "http://localhost";
+    if (/^https?:\/\//i.test(value))
+        return new URL(value).origin;
+    const host = value.split("/")[0];
+    const local = host === "localhost" || host.startsWith("localhost:");
+    return `${local ? "http" : "https"}://${host}`;
 }
 /** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */
 export const authGate = toPlugin(AuthGatePlugin);
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit plugin behind the tunnel's email-OTP gate.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns the allow-list, the per-email/per-IP rate limiters, the CacheManager-backed\n * one-time-code store, and the session JWT. `createApp` (with no `server()`) is\n * used only to auto-init `CacheManager` + prime the sibling `email` transport;\n * this plugin is where the gate logic lives.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport { Plugin, toPlugin, type BasePluginConfig, type PluginManifest } from \"@databricks/appkit\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport { brand, log, object, string } from \"@dbx-tools/shared-core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-email\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { CodeStore, signSession, verifySession } from \"./otp.ts\";\nimport { RateLimiter } from \"./rate-limit.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    publicDomain: coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Handle a code request. Always resolves `{ ok: true }` (anti-enumeration). */\n  request(email: string, ip: string): Promise<{ ok: true; retryAfter?: number }>;\n  /** Handle a code verification. On success returns the session token to cookie. */\n  verify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }>;\n  /** Resolve the authenticated email for a session token, or undefined. */\n  session(token: string | undefined): Promise<string | undefined>;\n  /** Session TTL in seconds (for the cookie Max-Age). */\n  readonly sessionTtlSeconds: number;\n  /** The gate status payload (`enabled` is always true when this plugin runs). */\n  status(token: string | undefined): Promise<AuthStatus>;\n}\n\n/**\n * AppKit plugin owning the email-OTP gate. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Email one-time-password access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private codes!: CodeStore;\n  // Requesting a code is email-spam-prone; verifying is a brute-force surface.\n  // Per-email AND per-IP so neither axis alone is a bypass.\n  private readonly requestLimiter = new RateLimiter(5, 15 * 60 * 1000);\n  private readonly verifyLimiter = new RateLimiter(10, 15 * 60 * 1000);\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n    this.codes = new CodeStore(this.resolved.codeTtlSeconds, this.resolved.maxAttempts);\n    // Resolve the signing key HERE rather than lazily on the first sign-in, so a\n    // cache that cannot hold it (and the resulting \"sessions won't survive a\n    // restart\" warning) shows up in the startup log, not hours later.\n    const { cutoffMs } = await signingKey(this.resolved.sessionCutoffMs);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no email-OTP gate\");\n    } else {\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      ...object.optional(\"sessionCutoff\", cutoffMs > 0 ? new Date(cutoffMs).toISOString() : null),\n    });\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the OTP gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  override exports(): AuthGateApi {\n    return {\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      request: (email, ip) => this.handleRequest(email, ip),\n      verify: (email, code, ip) => this.handleVerify(email, code, ip),\n      session: (token) => verifySession(token),\n      status: async (token) => ({\n        authenticated: Boolean(await verifySession(token)),\n        email: (await verifySession(token)) ?? undefined,\n        enabled: true,\n      }),\n    };\n  }\n\n  private async handleRequest(\n    email: string,\n    ip: string,\n  ): Promise<{ ok: true; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.requestLimiter.hit(`ip:${ip}`);\n    const byEmail = this.requestLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: true, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if (looksLikeEmail(address) && matchesAllowlist(address, this.resolved.allow)) {\n      const code = await this.codes.issue(address);\n      try {\n        await this.sendCode(address, code, {\n          subject: this.resolved.subject,\n          brandName: this.resolved.brandName,\n          message: this.resolved.message,\n          codeTtlSeconds: this.resolved.codeTtlSeconds,\n        });\n      } catch (error) {\n        logger.warn(\"failed to send OTP email\", { error });\n      }\n    }\n    return { ok: true };\n  }\n\n  private async handleVerify(\n    email: string,\n    code: string,\n    ip: string,\n  ): Promise<{ ok: boolean; token?: string; retryAfter?: number }> {\n    const address = email.trim().toLowerCase();\n    const byIp = this.verifyLimiter.hit(`ip:${ip}`);\n    const byEmail = this.verifyLimiter.hit(`email:${address}`);\n    if (!byIp.allowed || !byEmail.allowed) {\n      return { ok: false, retryAfter: byIp.retryAfter ?? byEmail.retryAfter };\n    }\n    if ((await this.codes.verify(address, code.trim())) !== \"ok\") return { ok: false };\n    this.requestLimiter.reset(`email:${address}`);\n    this.verifyLimiter.reset(`email:${address}`);\n    return { ok: true, token: await signSession(address, this.resolved.sessionTtlSeconds) };\n  }\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * `authGate()` - the AppKit adapter around `@dbx-tools/auth`.\n *\n * It has NO routes of its own: the tunnel PROXY (not an HTTP server) calls the\n * handlers this plugin exposes via {@link AuthGatePlugin.exports}. The plugin\n * owns tunnel authorization, AppKit Lakebase discovery, email delivery, and\n * transport mounting. Better Auth owns users, OTPs, sessions, rate limits, and\n * passkeys. `createApp` can run this plugin with or without `server()`.\n *\n * Options come from CLI flags OR env, with sensible defaults - see\n * {@link resolveAuthGateConfig}. The one runtime dependency the plugin can't\n * resolve itself is HOW to email the code, so it takes a `sendCode` callback the\n * app wires to the email plugin.\n *\n * @module\n */\n\nimport {\n  lakebase,\n  Plugin,\n  toPlugin,\n  type BasePluginConfig,\n  type PluginManifest,\n  type ResourceRequirement,\n  ResourceType,\n} from \"@databricks/appkit\";\nimport { plugin as appkitPlugin } from \"@dbx-tools/appkit\";\nimport {\n  auth as passwordlessAuth,\n  storage as authStorage,\n  type AuthorizeIdentity,\n  type AuthStorageConfig,\n  type AuthStorageMode,\n  type PasswordlessAuthRuntime,\n} from \"@dbx-tools/auth\";\nimport { config as coreConfig } from \"@dbx-tools/core\";\nimport type { AuthStatus } from \"@dbx-tools/shared-auth\";\nimport { brand, log, string } from \"@dbx-tools/shared-core\";\nimport type { RequestHandler } from \"express\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\nimport { looksLikeEmail, matchesAllowlist } from \"./allowlist.ts\";\nimport { mountGate, type GateOptions } from \"./gate.ts\";\nimport { ensureEmailAvailable, sendCode as defaultSendCode } from \"./send-code.ts\";\nimport { KEY_TTL_SECONDS, resolveSessionCutoff, signingKey } from \"./signing-key.ts\";\n\nconst logger = log.logger(\"tunnel:auth\");\n\ninterface GateServerApplication {\n  get(path: string, handler: RequestHandler): unknown;\n  post(path: string, handler: RequestHandler): unknown;\n  use(path: string, handler: RequestHandler): unknown;\n}\n\ninterface GateMountContext {\n  addRoute(method: string, path: string, handler: RequestHandler): void;\n  addMiddleware(path: string, handler: RequestHandler): void;\n  getPlugins(): ReadonlyMap<string, unknown>;\n}\n\nfunction serverApplication(context: GateMountContext): GateServerApplication | undefined {\n  const server = context.getPlugins().get(\"server\") as\n    { serverApplication?: Partial<GateServerApplication> } | undefined;\n  const application = server?.serverApplication;\n  return application &&\n    typeof application.get === \"function\" &&\n    typeof application.post === \"function\" &&\n    typeof application.use === \"function\"\n    ? (application as GateServerApplication)\n    : undefined;\n}\n\nexport function mountGateOnContext(context: GateMountContext, options: GateOptions): void {\n  const application = serverApplication(context);\n  if (application) {\n    mountGate(\n      options,\n      (method, path, handler) => application[method](path, handler),\n      (path, handler) => application.use(path, handler),\n    );\n    return;\n  }\n  mountGate(\n    options,\n    (method, path, handler) => context.addRoute(method, path, handler),\n    (path, handler) => context.addMiddleware(path, handler),\n  );\n}\n\n/** Options for the {@link authGate} plugin (all resolvable from env - see below). */\nexport interface AuthGateConfig extends BasePluginConfig, AuthStorageConfig {\n  /** Allow-list patterns (domain / glob / `/regex/`). Empty = allow nobody. Env TUNNEL_AUTH_ALLOW. */\n  allow?: string | string[];\n  /**\n   * Subject line for the code email. Env TUNNEL_AUTH_SUBJECT.\n   *\n   * Defaults to \"Your verification code\". The wording of the subject and\n   * {@link message} is deliberately the conventional phrasing rather than\n   * anything branded: iOS, Gmail, Outlook, and Android all detect a one-time\n   * code from this shape and offer to autofill it, and a novel phrasing is what\n   * breaks that detection.\n   *\n   * This is the subject TEMPLATE, not the literal line sent: the code is spliced\n   * into it (`\"123456 is your verification code\"`) because a push notification\n   * shows only the subject and preheader, and that notification is what mobile\n   * autofill reads. See `codeEmailSubject` in `./code-email.ts`.\n   */\n  subject?: string;\n  /**\n   * Display name used in the code email copy. Env TUNNEL_AUTH_BRAND_NAME.\n   *\n   * Defaults to the brand context's `name` - the app's own `branding/brand.yaml`\n   * when it has one, else the dbx-tools default. Set this only to override the\n   * brand for this gate.\n   */\n  brandName?: string;\n  /**\n   * Line shown immediately above the code in the email. Env TUNNEL_AUTH_MESSAGE.\n   *\n   * Keep the code on its OWN line directly after this text - that adjacency is\n   * what the platform code-detection heuristics key on.\n   */\n  message?: string;\n  /**\n   * Session lifetime (seconds). Env TUNNEL_AUTH_SESSION_TTL. Default 2592000 (30d).\n   *\n   * Matched to the cache-backed signing key's own 30-day TTL (see\n   * `./signing-key.ts`): the cookie and the key that validates it should expire\n   * together, or one silently outlives the other.\n   */\n  sessionTtlSeconds?: number;\n  /** One-time-code lifetime (seconds). Env TUNNEL_AUTH_CODE_TTL. Default 600 (10m). */\n  codeTtlSeconds?: number;\n  /** Max verify attempts per issued code. Default 5. */\n  maxAttempts?: number;\n  /**\n   * Force-clear cutoff: every session issued BEFORE it stops verifying, so moving\n   * it forward signs everyone out. Env TUNNEL_AUTH_SESSION_CUTOFF.\n   *\n   * Anything `object.toDate` accepts: a `Date`, `2026-08-02`, an ISO instant,\n   * epoch seconds/millis, or a relative duration (`-30d`, `7 days ago`). Unset\n   * means no cutoff.\n   */\n  sessionCutoff?: string | number | Date;\n  /**\n   * Deliver a code to an address. Defaults to sending through the host app's\n   * shared `@dbx-tools/email` transport (see `./send-code`); override to wire a\n   * different delivery path.\n   */\n  sendCode?: (email: string, code: string, opts: SendCodeOptions) => Promise<void>;\n  /**\n   * Identity authorization independent of authentication. Defaults to the\n   * configured allow-list and is re-evaluated for every accepted session.\n   */\n  authorizeIdentity?: AuthorizeIdentity;\n  /**\n   * The public `<subdomain>.<server>` that identifies portr traffic by its `Host`\n   * header. Only requests whose `Host` matches this are gated; everything else\n   * (the platform front door, other local callers) passes through. Env\n   * `TUNNEL_PUBLIC_DOMAIN`. When absent, the gate is inert (nothing is tunnel\n   * traffic).\n   */\n  publicDomain?: string;\n  /**\n   * Extra `x-` request headers tunnel traffic may forward (literal / glob /\n   * `/regex/`), unioned with the built-in allow-list. Env `TUNNEL_FORWARD_HEADERS`.\n   */\n  forwardHeaders?: string | string[];\n  /**\n   * Run OPEN with no gate (env `TUNNEL_INSECURE=true`). The login routes and gate\n   * middleware are not mounted, and the SMTP fail-fast is skipped. Use only when\n   * the tunnel is deliberately public.\n   */\n  insecure?: boolean;\n}\n\n/** Branding/messaging passed to {@link AuthGateConfig.sendCode}. */\nexport interface SendCodeOptions {\n  subject: string;\n  brandName: string;\n  message: string;\n  /**\n   * Lifetime of the code being sent, in seconds - the RESOLVED\n   * {@link AuthGateConfig.codeTtlSeconds}, so the email can state the real\n   * expiry (\"This code expires in 10 minutes\") instead of a vague \"shortly\"\n   * that drifts from the configured TTL.\n   */\n  codeTtlSeconds: number;\n}\n\n/** Resolved gate config with env fallbacks + defaults applied. */\nexport interface ResolvedAuthGateConfig {\n  allow: string[];\n  subject: string;\n  brandName: string;\n  message: string;\n  sessionTtlSeconds: number;\n  codeTtlSeconds: number;\n  maxAttempts: number;\n  /** Force-clear cutoff in epoch ms; `0` when unset. */\n  sessionCutoffMs: number;\n  /** Public domain that identifies portr traffic by `Host`; `undefined` = inert. */\n  publicDomain?: string;\n  /** Extra `x-` headers tunnel traffic may forward (unioned with the defaults). */\n  forwardHeaders: string[];\n  /** Run OPEN with no gate. */\n  insecure: boolean;\n  storage: AuthStorageMode;\n  sqlitePath?: string;\n}\n\nconst DEFAULTS = {\n  subject: \"Your verification code\",\n  // The repo-wide brand context's display name, NOT a hardcoded product string:\n  // this name is what the recipient reads in the code email, so it has to be the\n  // same identity the rest of the app presents. A host with its own\n  // `branding/brand.yaml` overrides it by passing `brandName`; the shared default\n  // is the fallback when nothing is configured.\n  brandName: brand.defaultBrandContext.name,\n  message: \"Your verification code is:\",\n  // 30 days, the same window the cache-backed signing key is stored for.\n  sessionTtlSeconds: KEY_TTL_SECONDS,\n  codeTtlSeconds: 600,\n  maxAttempts: 5,\n};\n\n/** Merge {@link AuthGateConfig} over env over defaults into a resolved config. */\nexport function resolveAuthGateConfig(config: AuthGateConfig): ResolvedAuthGateConfig {\n  const storage = authStorage.resolveAuthStorageConfig({\n    storage:\n      config.storage ??\n      (coreConfig.text(\"AUTH_STORAGE\", TUNNEL_CONFIG) as AuthStorageMode | undefined),\n    sqlitePath: config.sqlitePath ?? coreConfig.text(\"AUTH_SQLITE_PATH\", TUNNEL_CONFIG),\n  });\n  return {\n    // Both sources are unioned rather than one overriding: a deployment-wide\n    // TUNNEL_AUTH_ALLOW and a per-invocation `--allow` should both grant access.\n    // Hence `parseList` on each rather than `config.list`, which stops at the\n    // first source that yields anything.\n    allow: [\n      ...string.parseList(config.allow),\n      ...string.parseList(coreConfig.text([\"AUTH_ALLOW\", \"EMAIL_AUTH_ALLOW\"], TUNNEL_CONFIG)),\n    ],\n    subject: coreConfig.string(config.subject, \"AUTH_SUBJECT\", TUNNEL_CONFIG) ?? DEFAULTS.subject,\n    brandName:\n      coreConfig.string(config.brandName, \"AUTH_BRAND_NAME\", TUNNEL_CONFIG) ?? DEFAULTS.brandName,\n    message: coreConfig.string(config.message, \"AUTH_MESSAGE\", TUNNEL_CONFIG) ?? DEFAULTS.message,\n    sessionTtlSeconds: coreConfig.positiveInt(\n      config.sessionTtlSeconds,\n      \"AUTH_SESSION_TTL\",\n      DEFAULTS.sessionTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    codeTtlSeconds: coreConfig.positiveInt(\n      config.codeTtlSeconds,\n      \"AUTH_CODE_TTL\",\n      DEFAULTS.codeTtlSeconds,\n      TUNNEL_CONFIG,\n    ),\n    maxAttempts: config.maxAttempts ?? DEFAULTS.maxAttempts,\n    sessionCutoffMs: resolveSessionCutoff(config.sessionCutoff),\n    publicDomain: coreConfig.string(config.publicDomain, \"PUBLIC_DOMAIN\", TUNNEL_CONFIG),\n    forwardHeaders: [\n      ...string.parseList(config.forwardHeaders),\n      ...string.parseList(coreConfig.text(\"FORWARD_HEADERS\", TUNNEL_CONFIG)),\n    ],\n    insecure: coreConfig.boolean(config.insecure, \"INSECURE\", TUNNEL_CONFIG) ?? false,\n    storage: storage.mode,\n    sqlitePath: storage.sqlitePath,\n  };\n}\n\n/** The handlers the gate middleware calls in-process (returned by {@link AuthGatePlugin.exports}). */\nexport interface AuthGateApi {\n  /** Better Auth and compatibility routes under `/api/email/auth/*`. */\n  handler(request: Request): Promise<Response>;\n  /** Resolve the authorized email for request headers, or undefined. */\n  session(headers: Headers): Promise<string | undefined>;\n  /** The gate status payload. */\n  status(headers: Headers): Promise<AuthStatus>;\n  /** Whether the runtime exposes passkey enrollment and authentication. */\n  readonly passkeysEnabled: boolean;\n  /** Close auth storage owned by this runtime. */\n  close(): Promise<void>;\n}\n\n/**\n * AppKit plugin adapting `@dbx-tools/auth` to tunnel traffic. On `setup()` it registers the login\n * routes (`/api/email/auth/*`) and a gating middleware on the app's OWN Express\n * server via `this.context`, so a public portr caller must prove an email before\n * reaching the app's `/api/*` - see `./gate`. Front-door (platform) traffic and\n * other local callers pass through untouched (the gate keys on the `Host` header).\n */\nexport class AuthGatePlugin extends Plugin<AuthGateConfig> {\n  static manifest = {\n    name: \"authGate\",\n    displayName: \"Auth Gate\",\n    description: \"Better Auth email OTP and passkey access gate for a public tunnel.\",\n    stability: \"beta\",\n    resources: {\n      required: [],\n      optional: [\n        {\n          type: ResourceType.POSTGRES,\n          alias: \"auth\",\n          resourceKey: \"auth-database\",\n          description: \"Durable users, sessions, OTP records, and passkeys.\",\n          permission: \"CAN_CONNECT_AND_CREATE\",\n          fields: {\n            instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n            database_name: { env: \"PGDATABASE\" },\n          },\n        },\n      ],\n    },\n  } satisfies PluginManifest<\"authGate\">;\n\n  private resolved!: ResolvedAuthGateConfig;\n  private runtime?: PasswordlessAuthRuntime;\n\n  static getResourceRequirements(config: AuthGateConfig): ResourceRequirement[] {\n    if (authStorage.resolveAuthStorageConfig(config).mode !== \"lakebase\") return [];\n    return [\n      {\n        type: ResourceType.POSTGRES,\n        alias: \"auth\",\n        resourceKey: \"auth-database\",\n        description: \"Durable users, sessions, OTP records, and passkeys.\",\n        permission: \"CAN_CONNECT_AND_CREATE\",\n        fields: {\n          instance_name: { env: \"LAKEBASE_INSTANCE_NAME\" },\n          database_name: { env: \"PGDATABASE\" },\n        },\n        required: true,\n      },\n    ];\n  }\n\n  override async setup(): Promise<void> {\n    this.resolved = resolveAuthGateConfig(this.config);\n\n    if (this.resolved.insecure) {\n      logger.warn(\"insecure mode - the tunnel runs OPEN with no auth gate\");\n    } else {\n      const lakebasePlugin = appkitPlugin.instance(this.context, lakebase);\n      const storage = await authStorage.createAuthStorage(\n        this.resolved,\n        lakebasePlugin?.exports().pool,\n      );\n      const { key } = await signingKey(this.resolved.sessionCutoffMs);\n      this.runtime = await passwordlessAuth.createPasswordlessAuth({\n        storage,\n        baseURL: authOrigin(this.resolved.publicDomain),\n        basePath: \"/api/email/auth\",\n        appName: this.resolved.brandName,\n        secret: Buffer.from(key).toString(\"base64url\"),\n        sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n        sessionCutoffMs: this.resolved.sessionCutoffMs,\n        codeTtlSeconds: this.resolved.codeTtlSeconds,\n        maxAttempts: this.resolved.maxAttempts,\n        authorizeIdentity: (email) => this.authorizeIdentity(email),\n        sendCode: (email, code, options) => this.sendCode(email, code, options),\n        subject: this.resolved.subject,\n        message: this.resolved.message,\n      });\n      // `server()` is deferred, so it does not exist during this plugin's setup.\n      // At `setup:complete` the Express app exists but has not injected plugin\n      // routes or static handling yet, which is the one point the gate can mount\n      // ahead of every protected route.\n      this.context?.onLifecycle(\"setup:complete\", async () => {\n        this.mountGateRoutes();\n        // Fail fast once the sibling email plugin has primed its transport: a\n        // gate that cannot email a code lets nobody in.\n        if (!this.config.sendCode) await ensureEmailAvailable();\n      });\n    }\n\n    logger.info(\"ready\", {\n      patterns: this.resolved.allow.length,\n      sessionTtlSeconds: this.resolved.sessionTtlSeconds,\n      publicDomain: this.resolved.publicDomain ?? null,\n      insecure: this.resolved.insecure,\n      storage: this.resolved.storage,\n      sessionCutoff:\n        this.resolved.sessionCutoffMs > 0\n          ? new Date(this.resolved.sessionCutoffMs).toISOString()\n          : null,\n    });\n  }\n\n  async shutdown(): Promise<void> {\n    await this.runtime?.close();\n  }\n\n  /**\n   * Register the login routes (`/api/email/auth/*`) and the gating middleware on\n   * the app's OWN Express server. At `setup:complete`, the deferred server plugin\n   * has constructed its Express app but has not injected plugin routes or static\n   * handling, so direct registration puts the gate first. The context's buffered\n   * route API remains a fallback for compatible non-standard server plugins.\n   */\n  private mountGateRoutes(): void {\n    const context = this.context;\n    if (!context) {\n      logger.warn(\"no plugin context - the auth gate cannot mount its routes\");\n      return;\n    }\n    mountGateOnContext(context, {\n      gate: this.exports(),\n      publicDomain: this.resolved.publicDomain,\n      forwardHeaders: this.resolved.forwardHeaders,\n    });\n  }\n\n  /** The code sender: the configured `sendCode`, else the shared-transport default. */\n  private get sendCode(): NonNullable<AuthGateConfig[\"sendCode\"]> {\n    return this.config.sendCode ?? defaultSendCode;\n  }\n\n  private authorizeIdentity(email: string): boolean | Promise<boolean> {\n    if (this.config.authorizeIdentity) return this.config.authorizeIdentity(email);\n    return looksLikeEmail(email) && matchesAllowlist(email, this.resolved.allow);\n  }\n\n  override exports(): AuthGateApi {\n    const runtime = this.runtime;\n    return {\n      passkeysEnabled: runtime?.passkeysEnabled ?? false,\n      handler: (request) =>\n        runtime?.handler(request) ?? Promise.resolve(new Response(\"Not Found\", { status: 404 })),\n      session: (headers) => runtime?.session(headers) ?? Promise.resolve(undefined),\n      status: (headers) =>\n        runtime?.status(headers) ??\n        Promise.resolve({ authenticated: false, enabled: false, passkeysEnabled: false }),\n      close: () => runtime?.close() ?? Promise.resolve(),\n    };\n  }\n}\n\nfunction authOrigin(publicDomain?: string): string {\n  const value = string.trimToNull(publicDomain);\n  if (!value) return \"http://localhost\";\n  if (/^https?:\\/\\//i.test(value)) return new URL(value).origin;\n  const host = value.split(\"/\")[0]!;\n  const local = host === \"localhost\" || host.startsWith(\"localhost:\");\n  return `${local ? \"http\" : \"https\"}://${host}`;\n}\n\n/** Factory: `authGate({ allow, subject, ... })` for an AppKit `plugins` array. */\nexport const authGate = toPlugin(AuthGatePlugin);\n"]}

package/lib/src/signing-key.d.ts

@@ -1,5 +1,5 @@
 /**
- * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ * The gate's Better Auth secret, persisted in AppKit's cache.
  *
  * The key decides whether a session COOKIE still verifies, so it must OUTLIVE the
  * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie
@@ -75,7 +75,7 @@ export interface SigningKey {
  * plugin's `setup()` passes its resolved value there, before any request can
  * reach the lazy path.
  *
- * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed secret. A cache that is
  * unavailable degrades to an ephemeral per-process key (the previous behaviour)
  * rather than refusing to sign: the key only validates an ALREADY-issued session,
  * so losing it costs sessions, never admission - a caller still needs a code

package/lib/src/signing-key.js

@@ -1,5 +1,5 @@
 /**
- * The gate's HS256 session-signing key, persisted in AppKit's cache.
+ * The gate's Better Auth secret, persisted in AppKit's cache.
  *
  * The key decides whether a session COOKIE still verifies, so it must OUTLIVE the
  * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie
@@ -57,7 +57,7 @@ const logger = log.logger("tunnel:signing-key");
 export const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;
 /** Cache-key prefix for the signing key, namespaced away from other cache use. */
 const KEY_PREFIX = "tunnel:auth:signing-key:";
-/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */
+/** Bytes of entropy in a generated Better Auth secret. */
 const KEY_BYTES = 32;
 /**
  * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.
@@ -143,7 +143,7 @@ let pending;
  * plugin's `setup()` passes its resolved value there, before any request can
  * reach the lazy path.
  *
- * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is
+ * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed secret. A cache that is
  * unavailable degrades to an ephemeral per-process key (the previous behaviour)
  * rather than refusing to sign: the key only validates an ALREADY-issued session,
  * so losing it costs sessions, never admission - a caller still needs a code
@@ -170,4 +170,4 @@ export function signingKey(configuredCutoff) {
 export function resetSigningKey() {
     pending = undefined;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signing-key.js","sourceRoot":"","sources":["../../src/signing-key.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The gate's HS256 session-signing key, persisted in AppKit's cache.\n *\n * The key decides whether a session COOKIE still verifies, so it must OUTLIVE the\n * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie\n * on restart and make each signed-in user request a new code - painful for a tunnel,\n * which restarts whenever the app it wraps does. So the key is stored in the cache\n * AppKit already configured (memory, or Lakebase when the host wires a persistent\n * `CacheStorage`), and with persistent storage a restart keeps sessions alive for\n * {@link KEY_TTL_SECONDS}.\n *\n * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is\n * the right answer for a fleet: an operator-held secret needs no shared cache and\n * no convergence, and it survives a cache flush.\n *\n * ## get / generate / get\n *\n * Two instances booting at once both miss, so both would generate - and the loser\n * would sign cookies with a key the winner rejects. Resolution is a re-READ after\n * the write: whatever the cache holds afterwards is the key everyone adopts, so\n * the instances converge on ONE value instead of trusting the one they minted.\n * (`set` is not conditional in the cache API - there is no `setnx` to lean on -\n * and this runs once per process, so the extra round-trip is free.)\n *\n * A pathological interleave can still cost a key: if A writes between B's write\n * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -\n * a cookie minted in that window fails to verify and the holder signs in again -\n * and it cannot produce a key one instance TRUSTS but another rejects for longer\n * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race\n * entirely.\n *\n * ## Forcing every session to end\n *\n * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or\n * `--session-cutoff`), and that date is part of the cache KEY. Moving it forward\n * makes every prior key unreachable, so every cookie signed against it stops\n * verifying - the log-everyone-out switch, without having to find and flush a\n * cache entry. The cutoff is also asserted against each token's `iat`, so a\n * cookie that predates it is refused even if it was signed with the key that is\n * somehow still current.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { config } from \"@dbx-tools/core\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\n\nconst logger = log.logger(\"tunnel:signing-key\");\n\n/**\n * How long a cached signing key lives: 30 days.\n *\n * This is the ceiling on how long a session cookie can stay valid across\n * restarts, so it is deliberately >= the default session TTL - a key that expired\n * before the cookies it signed would log everyone out for no reason.\n */\nexport const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;\n\n/** Cache-key prefix for the signing key, namespaced away from other cache use. */\nconst KEY_PREFIX = \"tunnel:auth:signing-key:\";\n\n/** Bytes of entropy in a generated key (256-bit, matching HS256's hash width). */\nconst KEY_BYTES = 32;\n\n/** What the cache stores: the key plus when it was minted, for observability. */\ninterface StoredKey {\n  /** Base64url of the raw key bytes. */\n  secret: string;\n  /** When this key was generated, ISO-8601. */\n  createdAt: string;\n}\n\n/**\n * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.\n *\n * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO\n * instant, epoch seconds or millis from `date +%s`, or a relative duration\n * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this\n * usually wants: sign out everyone who signed in more than a month ago.\n *\n * An UNPARSEABLE value is ignored with a warning rather than throwing: this is\n * the switch that logs a fleet back in, and failing to boot over a typo is worse\n * than not rotating.\n */\nexport function resolveSessionCutoff(configured?: string | number | Date): number {\n  const raw =\n    configured ?? config.text([\"AUTH_SESSION_CUTOFF\", \"AUTH_SESSION_EPOCH\"], TUNNEL_CONFIG);\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n\n  const date = object.toDate(raw);\n  if (!date) {\n    logger.warn(`ignoring unparseable ${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)}`, {\n      value: String(raw),\n    });\n    return 0;\n  }\n  return clampToPast(date.getTime());\n}\n\n/**\n * Hold the cutoff at \"now\", because a FUTURE cutoff would refuse the sessions it\n * is about to mint as well as the old ones - an app nobody can sign in to, from a\n * mistyped year, with the fix hidden behind understanding this flag. Clamped, a\n * future date means what an operator setting it always meant: clear everything\n * outstanding, then carry on.\n */\nfunction clampToPast(cutoffMs: number): number {\n  const now = Date.now();\n  if (cutoffMs <= now) return cutoffMs;\n  logger.warn(\n    `${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)} is in the future - clamping to now`,\n    {\n      configured: new Date(cutoffMs).toISOString(),\n    },\n  );\n  return now;\n}\n\n/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */\nfunction cacheKey(cutoffMs: number): string {\n  return `${KEY_PREFIX}${cutoffMs}`;\n}\n\nfunction decode(stored: StoredKey): Uint8Array {\n  return new Uint8Array(Buffer.from(stored.secret, \"base64url\"));\n}\n\n/**\n * Load the signing key for `cutoffMs` from the cache, minting and storing one\n * when absent. See the module docs for why the write is followed by a re-read.\n */\nasync function loadFromCache(cutoffMs: number): Promise<Uint8Array> {\n  const cache = CacheManager.getInstanceSync();\n  const key = cacheKey(cutoffMs);\n\n  const existing = await cache.get<StoredKey>(key);\n  if (existing?.secret) {\n    logger.info(\"reusing cached signing key\", { createdAt: existing.createdAt });\n    return decode(existing);\n  }\n\n  const minted: StoredKey = {\n    secret: Buffer.from(randomBytes(KEY_BYTES)).toString(\"base64url\"),\n    createdAt: new Date().toISOString(),\n  };\n  await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });\n\n  // Re-read rather than trusting `minted`: another instance that raced this boot\n  // may have written first, and adopting whatever is stored is what makes the two\n  // converge on one key.\n  const settled = (await cache.get<StoredKey>(key)) ?? minted;\n  logger.info(\"stored a new signing key\", {\n    createdAt: settled.createdAt,\n    ttlSeconds: KEY_TTL_SECONDS,\n    adopted: settled.createdAt === minted.createdAt ? \"own\" : \"concurrent-instance\",\n  });\n  return decode(settled);\n}\n\n/** A resolved key plus the cutoff it is scoped to. */\nexport interface SigningKey {\n  key: Uint8Array;\n  /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */\n  cutoffMs: number;\n}\n\nlet pending: Promise<SigningKey> | undefined;\n\n/**\n * The signing key for this gate, resolved once per process.\n *\n * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the\n * plugin's `setup()` passes its resolved value there, before any request can\n * reach the lazy path.\n *\n * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed key. A cache that is\n * unavailable degrades to an ephemeral per-process key (the previous behaviour)\n * rather than refusing to sign: the key only validates an ALREADY-issued session,\n * so losing it costs sessions, never admission - a caller still needs a code\n * delivered to an allow-listed address.\n */\nexport function signingKey(configuredCutoff?: string | number | Date): Promise<SigningKey> {\n  pending ??= (async () => {\n    const cutoffMs = resolveSessionCutoff(configuredCutoff);\n    const configured = config.text(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG);\n    if (configured) {\n      return { key: new TextEncoder().encode(configured), cutoffMs };\n    }\n    try {\n      return { key: await loadFromCache(cutoffMs), cutoffMs };\n    } catch (error) {\n      logger.warn(\n        `no ${config.name(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`,\n        { error },\n      );\n      return { key: new Uint8Array(randomBytes(KEY_BYTES)), cutoffMs };\n    }\n  })();\n  return pending;\n}\n\n/** Reset the per-process key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  pending = undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signing-key.js","sourceRoot":"","sources":["../../src/signing-key.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The gate's Better Auth secret, persisted in AppKit's cache.\n *\n * The key decides whether a session COOKIE still verifies, so it must OUTLIVE the\n * process: a per-process `randomBytes(32)` would invalidate every outstanding cookie\n * on restart and make each signed-in user request a new code - painful for a tunnel,\n * which restarts whenever the app it wraps does. So the key is stored in the cache\n * AppKit already configured (memory, or Lakebase when the host wires a persistent\n * `CacheStorage`), and with persistent storage a restart keeps sessions alive for\n * {@link KEY_TTL_SECONDS}.\n *\n * An explicitly configured `TUNNEL_AUTH_JWT_SECRET` still wins outright. That is\n * the right answer for a fleet: an operator-held secret needs no shared cache and\n * no convergence, and it survives a cache flush.\n *\n * ## get / generate / get\n *\n * Two instances booting at once both miss, so both would generate - and the loser\n * would sign cookies with a key the winner rejects. Resolution is a re-READ after\n * the write: whatever the cache holds afterwards is the key everyone adopts, so\n * the instances converge on ONE value instead of trusting the one they minted.\n * (`set` is not conditional in the cache API - there is no `setnx` to lean on -\n * and this runs once per process, so the extra round-trip is free.)\n *\n * A pathological interleave can still cost a key: if A writes between B's write\n * and B's re-read, B adopts A's key while A adopts its own. The cost is bounded -\n * a cookie minted in that window fails to verify and the holder signs in again -\n * and it cannot produce a key one instance TRUSTS but another rejects for longer\n * than the window itself. Set `TUNNEL_AUTH_JWT_SECRET` to remove the race\n * entirely.\n *\n * ## Forcing every session to end\n *\n * {@link resolveSessionCutoff} reads a date from `TUNNEL_AUTH_SESSION_CUTOFF` (or\n * `--session-cutoff`), and that date is part of the cache KEY. Moving it forward\n * makes every prior key unreachable, so every cookie signed against it stops\n * verifying - the log-everyone-out switch, without having to find and flush a\n * cache entry. The cutoff is also asserted against each token's `iat`, so a\n * cookie that predates it is refused even if it was signed with the key that is\n * somehow still current.\n *\n * @module\n */\n\nimport { randomBytes } from \"node:crypto\";\nimport { CacheManager } from \"@databricks/appkit\";\nimport { config } from \"@dbx-tools/core\";\nimport { log, object } from \"@dbx-tools/shared-core\";\nimport { TUNNEL_CONFIG } from \"./_config.ts\";\n\nconst logger = log.logger(\"tunnel:signing-key\");\n\n/**\n * How long a cached signing key lives: 30 days.\n *\n * This is the ceiling on how long a session cookie can stay valid across\n * restarts, so it is deliberately >= the default session TTL - a key that expired\n * before the cookies it signed would log everyone out for no reason.\n */\nexport const KEY_TTL_SECONDS = 30 * 24 * 60 * 60;\n\n/** Cache-key prefix for the signing key, namespaced away from other cache use. */\nconst KEY_PREFIX = \"tunnel:auth:signing-key:\";\n\n/** Bytes of entropy in a generated Better Auth secret. */\nconst KEY_BYTES = 32;\n\n/** What the cache stores: the key plus when it was minted, for observability. */\ninterface StoredKey {\n  /** Base64url of the raw key bytes. */\n  secret: string;\n  /** When this key was generated, ISO-8601. */\n  createdAt: string;\n}\n\n/**\n * Resolve the force-clear cutoff as epoch MILLISECONDS, or `0` when unset.\n *\n * Accepts whatever `object.toDate` accepts - a `Date`, `2026-08-02`, an ISO\n * instant, epoch seconds or millis from `date +%s`, or a relative duration\n * (`-30d`, `7 days ago`), which is the spelling an operator reaching for this\n * usually wants: sign out everyone who signed in more than a month ago.\n *\n * An UNPARSEABLE value is ignored with a warning rather than throwing: this is\n * the switch that logs a fleet back in, and failing to boot over a typo is worse\n * than not rotating.\n */\nexport function resolveSessionCutoff(configured?: string | number | Date): number {\n  const raw =\n    configured ?? config.text([\"AUTH_SESSION_CUTOFF\", \"AUTH_SESSION_EPOCH\"], TUNNEL_CONFIG);\n  if (raw === undefined || raw === null || raw === \"\") return 0;\n\n  const date = object.toDate(raw);\n  if (!date) {\n    logger.warn(`ignoring unparseable ${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)}`, {\n      value: String(raw),\n    });\n    return 0;\n  }\n  return clampToPast(date.getTime());\n}\n\n/**\n * Hold the cutoff at \"now\", because a FUTURE cutoff would refuse the sessions it\n * is about to mint as well as the old ones - an app nobody can sign in to, from a\n * mistyped year, with the fix hidden behind understanding this flag. Clamped, a\n * future date means what an operator setting it always meant: clear everything\n * outstanding, then carry on.\n */\nfunction clampToPast(cutoffMs: number): number {\n  const now = Date.now();\n  if (cutoffMs <= now) return cutoffMs;\n  logger.warn(\n    `${config.name(\"AUTH_SESSION_CUTOFF\", TUNNEL_CONFIG)} is in the future - clamping to now`,\n    {\n      configured: new Date(cutoffMs).toISOString(),\n    },\n  );\n  return now;\n}\n\n/** The cache key for one cutoff, so moving the cutoff orphans every earlier key. */\nfunction cacheKey(cutoffMs: number): string {\n  return `${KEY_PREFIX}${cutoffMs}`;\n}\n\nfunction decode(stored: StoredKey): Uint8Array {\n  return new Uint8Array(Buffer.from(stored.secret, \"base64url\"));\n}\n\n/**\n * Load the signing key for `cutoffMs` from the cache, minting and storing one\n * when absent. See the module docs for why the write is followed by a re-read.\n */\nasync function loadFromCache(cutoffMs: number): Promise<Uint8Array> {\n  const cache = CacheManager.getInstanceSync();\n  const key = cacheKey(cutoffMs);\n\n  const existing = await cache.get<StoredKey>(key);\n  if (existing?.secret) {\n    logger.info(\"reusing cached signing key\", { createdAt: existing.createdAt });\n    return decode(existing);\n  }\n\n  const minted: StoredKey = {\n    secret: Buffer.from(randomBytes(KEY_BYTES)).toString(\"base64url\"),\n    createdAt: new Date().toISOString(),\n  };\n  await cache.set(key, minted, { ttl: KEY_TTL_SECONDS });\n\n  // Re-read rather than trusting `minted`: another instance that raced this boot\n  // may have written first, and adopting whatever is stored is what makes the two\n  // converge on one key.\n  const settled = (await cache.get<StoredKey>(key)) ?? minted;\n  logger.info(\"stored a new signing key\", {\n    createdAt: settled.createdAt,\n    ttlSeconds: KEY_TTL_SECONDS,\n    adopted: settled.createdAt === minted.createdAt ? \"own\" : \"concurrent-instance\",\n  });\n  return decode(settled);\n}\n\n/** A resolved key plus the cutoff it is scoped to. */\nexport interface SigningKey {\n  key: Uint8Array;\n  /** Force-clear cutoff in ms; `0` when unset. Tokens older than this are refused. */\n  cutoffMs: number;\n}\n\nlet pending: Promise<SigningKey> | undefined;\n\n/**\n * The signing key for this gate, resolved once per process.\n *\n * Resolved ONCE, so `configuredCutoff` is honoured only on the first call - the\n * plugin's `setup()` passes its resolved value there, before any request can\n * reach the lazy path.\n *\n * `TUNNEL_AUTH_JWT_SECRET` when set, else the cache-backed secret. A cache that is\n * unavailable degrades to an ephemeral per-process key (the previous behaviour)\n * rather than refusing to sign: the key only validates an ALREADY-issued session,\n * so losing it costs sessions, never admission - a caller still needs a code\n * delivered to an allow-listed address.\n */\nexport function signingKey(configuredCutoff?: string | number | Date): Promise<SigningKey> {\n  pending ??= (async () => {\n    const cutoffMs = resolveSessionCutoff(configuredCutoff);\n    const configured = config.text(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG);\n    if (configured) {\n      return { key: new TextEncoder().encode(configured), cutoffMs };\n    }\n    try {\n      return { key: await loadFromCache(cutoffMs), cutoffMs };\n    } catch (error) {\n      logger.warn(\n        `no ${config.name(\"AUTH_JWT_SECRET\", TUNNEL_CONFIG)} and the cache is unavailable - using an ephemeral per-process key; sessions will not survive a restart`,\n        { error },\n      );\n      return { key: new Uint8Array(randomBytes(KEY_BYTES)), cutoffMs };\n    }\n  })();\n  return pending;\n}\n\n/** Reset the per-process key (tests, or after changing the env in-process). */\nexport function resetSigningKey(): void {\n  pending = undefined;\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/otp.ts","../src/plugin.ts","../src/portr.ts","../src/rate-limit.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/_config.ts","../src/allowlist.ts","../src/code-email.ts","../src/gate.ts","../src/headers.ts","../src/interceptor.ts","../src/plugin.ts","../src/portr.ts","../src/send-code.ts","../src/signing-key.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -18,21 +18,21 @@
     "projen": "projen"
   },
   "devDependencies": {
-    "@dbx-tools/email": "0.6.89",
+    "@dbx-tools/email": "0.6.91",
     "@types/bun": "^1.3.14",
     "@types/node": "^24.6.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@dbx-tools/email": "0.6.89"
+    "@dbx-tools/email": "0.6.91"
   },
   "dependencies": {
     "@databricks/appkit": "^0.43.0",
-    "@dbx-tools/appkit": "0.6.89",
-    "@dbx-tools/core": "0.6.89",
-    "@dbx-tools/shared-core": "0.6.89",
-    "@dbx-tools/shared-email": "0.6.89",
-    "jose": "^6.2.3"
+    "@dbx-tools/appkit": "0.6.91",
+    "@dbx-tools/auth": "0.6.91",
+    "@dbx-tools/core": "0.6.91",
+    "@dbx-tools/shared-auth": "0.6.91",
+    "@dbx-tools/shared-core": "0.6.91"
   },
   "main": "./lib/index.js",
   "license": "UNLICENSED",
@@ -48,7 +48,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.89",
+  "version": "0.6.91",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/allowlist.ts

@@ -1,5 +1,5 @@
 /**
- * Unified access allow-list matching for the email-OTP gate.
+ * Unified identity authorization matching for the passwordless gate.
  *
  * Each pattern in the configured list is one of three shapes:
  *