okengine 0.7.0 → 0.9.0

package/src/kernel/journal.ts

@@ -9,6 +9,9 @@
 
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
+import { JournalSuspend } from "./journal-suspend.ts";
+
+export { JournalSuspend, isJournalSuspend } from "./journal-suspend.ts";
 
 /** Status of a durable run. */
 export type JournalRunStatus = "running" | "sleeping" | "completed" | "failed";
@@ -53,32 +56,58 @@ export interface JournalRun {
   wakeAt?: number;
   error?: string;
   output?: unknown;
+  /** Lease holder instance id (run-level coordination — Signal/Clock physics). */
+  lockedBy?: string;
+  /** Lease expiry epoch-ms; a crashed holder's run is reclaimable after this. */
+  leaseExpiresAt?: number;
   readonly createdAt: number;
   updatedAt: number;
 }
 
 /**
- * Thrown inside a durable body when a sleep has not yet elapsed.
- * The runner catches this and parks the run as `sleeping`.
+ * Run-level lease coordination — same SKIP LOCKED + lazy-reclaim physics as
+ * Signal's message claims and Clock's tick claims. No sweeper, no fencing
+ * token: at-least-once after lease expiry, journal replay keeps completed
+ * steps from re-running.
  */
-export class JournalSuspend extends Error {
-  readonly wakeAt: number;
-  readonly label: string;
-
+export interface JournalLeaseStore {
   /**
-   * @param label - Sleep label
-   * @param wakeAt - Absolute wake epoch-ms
+   * Acquire / renew / reclaim a run lease. Claimable when unlocked, held by
+   * the same instance, or expired.
+   *
+   * @param runId - Run id
+   * @param instanceId - Claimant instance
+   * @param now - Epoch-ms
+   * @param leaseMs - Lease duration
    */
-  constructor(label: string, wakeAt: number) {
-    super(`journal suspend: sleep "${label}" until ${wakeAt}`);
-    this.name = "JournalSuspend";
-    this.label = label;
-    this.wakeAt = wakeAt;
-  }
+  acquireLease(runId: string, instanceId: string, now: number, leaseMs: number): Promise<boolean>;
+  /**
+   * Release a lease held by `instanceId` (no-op for other holders).
+   *
+   * @param runId - Run id
+   * @param instanceId - Holder instance
+   */
+  releaseLease(runId: string, instanceId: string): Promise<void>;
+  /**
+   * Atomically claim the next due sleep (`status=sleeping`, `wakeAt<=now`, no
+   * live lease) and return it — `undefined` when none is claimable.
+   *
+   * @param instanceId - Claimant instance
+   * @param now - Epoch-ms
+   * @param leaseMs - Lease duration
+   */
+  claimDueSleep(instanceId: string, now: number, leaseMs: number): Promise<JournalRun | undefined>;
+  /**
+   * Boot-time orphan discovery: `running` / `sleeping` runs with no live lease
+   * (crashed holder or never claimed). Rows are never deleted.
+   *
+   * @param now - Epoch-ms
+   */
+  listOrphans(now: number): Promise<readonly JournalRun[]>;
 }
 
 /** Persistence backend for journal runs. */
-export interface JournalStore {
+export interface JournalStore extends Partial<JournalLeaseStore> {
   /**
    * Load a run by id.
    *
@@ -95,12 +124,107 @@ export interface JournalStore {
   list(): Promise<readonly JournalRun[]>;
 }
 
+/** Default run lease — matches Signal's claim lease. */
+export const JOURNAL_DEFAULT_LEASE_MS = 30_000;
+
+/**
+ * Narrow a store to its lease-coordination surface (present on the built-in
+ * memory / file / postgres stores; absent on custom minimal stores).
+ *
+ * @param store - Journal store
+ */
+export function hasJournalLease(store: JournalStore): store is JournalStore & JournalLeaseStore {
+  return (
+    typeof store.acquireLease === "function" &&
+    typeof store.releaseLease === "function" &&
+    typeof store.claimDueSleep === "function" &&
+    typeof store.listOrphans === "function"
+  );
+}
+
+/** Thrown when a run resume loses the lease race to another live instance. */
+export class JournalLeaseBusy extends Error {
+  readonly runId: string;
+  constructor(runId: string) {
+    super(`journal: run "${runId}" is leased by another instance`);
+    this.name = "JournalLeaseBusy";
+    this.runId = runId;
+  }
+}
+
+/** Type guard for {@link JournalLeaseBusy}. */
+export function isJournalLeaseBusy(err: unknown): err is JournalLeaseBusy {
+  return err instanceof JournalLeaseBusy;
+}
+
+/** Live lease = a holder with an unexpired expiry. */
+function hasLiveLease(run: JournalRun, now: number): boolean {
+  return run.lockedBy !== undefined && run.leaseExpiresAt !== undefined && run.leaseExpiresAt > now;
+}
+
+/** Claimable when unlocked, same-holder, or without a live lease. */
+function claimable(run: JournalRun, instanceId: string, now: number): boolean {
+  if (run.lockedBy === undefined) return true;
+  if (run.lockedBy === instanceId) return true;
+  return !hasLiveLease(run, now);
+}
+
+/** Lease methods shared by the memory + file stores (single-writer maps). */
+function leaseMethods(
+  load: () => Promise<Map<string, JournalRun>>,
+  flush?: (map: Map<string, JournalRun>) => Promise<void>,
+): JournalLeaseStore {
+  return {
+    async acquireLease(runId, instanceId, now, leaseMs) {
+      const map = await load();
+      const run = map.get(runId);
+      if (!run || !claimable(run, instanceId, now)) return false;
+      run.lockedBy = instanceId;
+      run.leaseExpiresAt = now + leaseMs;
+      await flush?.(map);
+      return true;
+    },
+    async releaseLease(runId, instanceId) {
+      const map = await load();
+      const run = map.get(runId);
+      if (!run || run.lockedBy !== instanceId) return;
+      delete run.lockedBy;
+      delete run.leaseExpiresAt;
+      await flush?.(map);
+    },
+    async claimDueSleep(instanceId, now, leaseMs) {
+      const map = await load();
+      const due = [...map.values()]
+        .filter(
+          (r) =>
+            r.status === "sleeping" &&
+            r.wakeAt !== undefined &&
+            r.wakeAt <= now &&
+            claimable(r, instanceId, now),
+        )
+        .sort((a, b) => (a.wakeAt ?? 0) - (b.wakeAt ?? 0))[0];
+      if (!due) return undefined;
+      due.lockedBy = instanceId;
+      due.leaseExpiresAt = now + leaseMs;
+      await flush?.(map);
+      return cloneRun(due);
+    },
+    async listOrphans(now) {
+      const map = await load();
+      return [...map.values()]
+        .filter((r) => (r.status === "running" || r.status === "sleeping") && !hasLiveLease(r, now))
+        .map(cloneRun);
+    },
+  };
+}
+
 /** In-memory journal store. */
 export function createMemoryJournalStore(seed?: readonly JournalRun[]): JournalStore {
   const runs = new Map<string, JournalRun>();
   for (const r of seed ?? []) {
     runs.set(r.id, cloneRun(r));
   }
+  const load = async (): Promise<Map<string, JournalRun>> => runs;
   return {
     async get(runId) {
       const r = runs.get(runId);
@@ -112,6 +236,7 @@ export function createMemoryJournalStore(seed?: readonly JournalRun[]): JournalS
     async list() {
       return [...runs.values()].map(cloneRun);
     },
+    ...leaseMethods(load),
   };
 }
 
@@ -156,9 +281,19 @@ export function createFileJournalStore(path: string): JournalStore {
       const map = await load();
       return [...map.values()].map(cloneRun);
     },
+    // Single-host file: leases coordinate same-machine processes only.
+    ...leaseMethods(load, flush),
   };
 }
 
+/** Run-level lease holder for {@link CreateJournalOptions.lease}. */
+export interface JournalLeaseOptions {
+  /** This instance's id (lease holder). */
+  readonly instanceId: string;
+  /** Lease duration ms (default {@link JOURNAL_DEFAULT_LEASE_MS}). */
+  readonly leaseMs?: number;
+}
+
 /** Options for {@link createJournal}. */
 export interface CreateJournalOptions {
   /** Persistence backend. */
@@ -167,6 +302,13 @@ export interface CreateJournalOptions {
   readonly now?: () => number;
   /** Id factory (defaults to UUID). */
   readonly id?: () => string;
+  /**
+   * Run-level lease (when the store supports it). `start` inserts with the
+   * lease held; `resume` claims the run or throws {@link JournalLeaseBusy};
+   * every persist renews; parking a sleep and terminal commits release so a
+   * sleeping/finished run never holds a 30s lock.
+   */
+  readonly lease?: JournalLeaseOptions;
 }
 
 /**
@@ -240,16 +382,31 @@ export interface Journal {
 export function createJournal(options: CreateJournalOptions): Journal {
   const now = options.now ?? (() => Date.now());
   const newId = options.id ?? (() => crypto.randomUUID());
+  const lease = options.lease;
+  const coordinated = lease !== undefined && hasJournalLease(options.store);
 
-  function openSession(run: JournalRun): JournalSession {
+  function openSession(run: JournalRun, leased: boolean): JournalSession {
     /** Next entry index to consume on replay. */
     let cursor = 0;
+    let leaseHeld = leased;
 
     async function persist(): Promise<void> {
       run.updatedAt = now();
+      // Natural heartbeat — a live holder renews on every journal write.
+      if (leaseHeld && lease) {
+        run.lockedBy = lease.instanceId;
+        run.leaseExpiresAt = now() + (lease.leaseMs ?? JOURNAL_DEFAULT_LEASE_MS);
+      }
       await options.store.put(cloneRun(run));
     }
 
+    /** Parking / terminal states must not hold a short lease across days. */
+    function releaseLeaseLocally(): void {
+      leaseHeld = false;
+      delete run.lockedBy;
+      delete run.leaseExpiresAt;
+    }
+
     return {
       runId: run.id,
       run,
@@ -282,6 +439,7 @@ export function createJournal(options: CreateJournalOptions): Journal {
             if (now() < e.wakeAt) {
               run.status = "sleeping";
               run.wakeAt = e.wakeAt;
+              releaseLeaseLocally();
               await persist();
               throw new JournalSuspend(label, e.wakeAt);
             }
@@ -301,6 +459,7 @@ export function createJournal(options: CreateJournalOptions): Journal {
         if (now() < wakeAt) {
           run.status = "sleeping";
           run.wakeAt = wakeAt;
+          releaseLeaseLocally();
           await persist();
           throw new JournalSuspend(label, wakeAt);
         }
@@ -341,6 +500,7 @@ export function createJournal(options: CreateJournalOptions): Journal {
         if (patch?.error !== undefined) run.error = patch.error;
         if (status === "completed" || status === "failed") {
           delete run.wakeAt;
+          releaseLeaseLocally();
         }
         await persist();
       },
@@ -360,31 +520,46 @@ export function createJournal(options: CreateJournalOptions): Journal {
         createdAt: t,
         updatedAt: t,
       };
+      if (coordinated && lease) {
+        // Fresh id — insert already holding the lease (no claim race).
+        run.lockedBy = lease.instanceId;
+        run.leaseExpiresAt = t + (lease.leaseMs ?? JOURNAL_DEFAULT_LEASE_MS);
+      }
       await options.store.put(cloneRun(run));
-      return openSession(run);
+      return openSession(run, coordinated);
     },
     async resume(runId) {
+      if (coordinated && lease) {
+        const t = now();
+        const claimed = await options.store.acquireLease!(
+          runId,
+          lease.instanceId,
+          t,
+          lease.leaseMs ?? JOURNAL_DEFAULT_LEASE_MS,
+        );
+        if (!claimed) {
+          throw new JournalLeaseBusy(runId);
+        }
+      }
       const run = await options.store.get(runId);
       if (!run) {
+        if (coordinated && lease) {
+          await options.store.releaseLease!(runId, lease.instanceId);
+        }
         throw new Error(`journal: run "${runId}" not found`);
       }
       // Leave status intact — the durable runner parks or continues.
       run.updatedAt = now();
+      if (coordinated && lease) {
+        run.lockedBy = lease.instanceId;
+        run.leaseExpiresAt = now() + (lease.leaseMs ?? JOURNAL_DEFAULT_LEASE_MS);
+      }
       await options.store.put(cloneRun(run));
-      return openSession(run);
+      return openSession(run, coordinated);
     },
   };
 }
 
-/**
- * True when `err` is a {@link JournalSuspend}.
- *
- * @param err - Unknown
- */
-export function isJournalSuspend(err: unknown): err is JournalSuspend {
-  return err instanceof JournalSuspend;
-}
-
 function cloneRun(run: JournalRun): JournalRun {
   return structuredClone(run);
 }

package/src/kernel/ready.test.ts

@@ -0,0 +1,76 @@
+/**
+ * Kernel readiness endpoint — boot vs orphan_scan vs ready.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { oke } from "./app.ts";
+import { flow, type AnyFlowDef } from "./flow.ts";
+import { createMemoryJournalStore, hasJournalLease } from "./journal.ts";
+import type { Binding } from "./on.ts";
+import { http } from "./triggers.ts";
+import { gate } from "../elements/gate.ts";
+
+describe("GET /_/ready", () => {
+  test("returns 503 booting before boot, 200 ready after boot without journal", async () => {
+    const app = oke({
+      name: "ready-plain",
+      autoBoot: false,
+      startScheduler: false,
+    });
+    const before = await app.fetch(new Request("http://127.0.0.1/_/ready"));
+    expect(before.status).toBe(503);
+    expect(await before.json()).toEqual({ ready: false, reason: "booting" });
+
+    await app.boot();
+    expect(app.readyState).toBe("ready");
+    const after = await app.fetch(new Request("http://127.0.0.1/_/ready"));
+    expect(after.status).toBe(200);
+    expect(await after.json()).toEqual({ ready: true });
+    await app.stop();
+  });
+
+  test("orphan_scan then ready when durable journal is bound", async () => {
+    const journalStore = createMemoryJournalStore();
+    expect(hasJournalLease(journalStore)).toBe(true);
+    const charge = flow({
+      name: "charge",
+      durable: true,
+      do: () => ({ ok: true }),
+    });
+    const bindings: Binding[] = [
+      {
+        trigger: http.post("/charge").gate(gate.public),
+        flow: charge as AnyFlowDef,
+      },
+    ];
+    const app = oke({
+      name: "ready-journal",
+      autoBoot: false,
+      startScheduler: false,
+      env: "test",
+      gate: { unguardedHttp: "allow" },
+      bindings,
+      elements: {
+        journal: {
+          store: journalStore,
+          instanceId: "ready-j",
+          leaseMs: 30_000,
+          driverId: "memory",
+        },
+      },
+    });
+    await app.boot();
+    // Memory journal orphan scan is fast — may already be ready; accept either
+    // intermediate orphan_scan or ready, but never stay booting after boot().
+    expect(["orphan_scan", "ready"]).toContain(app.readyState);
+    const deadline = Date.now() + 2_000;
+    while (app.readyState !== "ready" && Date.now() < deadline) {
+      await Bun.sleep(5);
+    }
+    expect(app.readyState).toBe("ready");
+    const res = await app.fetch(new Request("http://127.0.0.1/_/ready"));
+    expect(res.status).toBe(200);
+    await app.stop();
+  });
+});

package/src/plugins/auth-delivery.mailpit.integration.test.ts

@@ -14,7 +14,7 @@ import { deriveInfrastructure, writeDerivedFiles } from "../docker/index.ts";
 import { oke } from "../kernel/app.ts";
 import { resetFlowSeq } from "../kernel/flow.ts";
 import { resetBindings } from "../kernel/on.ts";
-import { emailOtp } from "./email-otp.ts";
+import { otp } from "./otp.ts";
 import { magicLink } from "./magic-link.ts";
 
 const SECRET = "test-secret-at-least-16";
@@ -290,21 +290,21 @@ describe("auth delivery — Mailpit integration", () => {
           config: {
             drivers: { channel: { email: { test: "smtp" } } },
           },
-        }).plug(emailOtp({ exposeDevOtp: true }));
+        }).plug(otp({ tier: 2, channels: ["email"], exposeDevOtp: true }));
         await app.boot({ env: "test" });
 
-        const res = await app.fetch(jsonPost("/auth/email-otp/request", { email }));
+        const res = await app.fetch(jsonPost("/auth/otp/request", { email }));
         expect(res.status).toBe(200);
         const body = (await res.json()) as { data: { ok: true; devOtp?: string } };
         expect(body.data.ok).toBe(true);
         expect(body.data.devOtp).toMatch(/^\d{6}$/);
-        const otp = body.data.devOtp!;
+        const code = body.data.devOtp!;
 
         const msg = await waitForMessage(uiUrl, email);
         expect(msg.Subject).toBe("Your sign-in code");
         const text = msg.Text ?? "";
         const html = msg.HTML ?? "";
-        expect(text.includes(otp) || html.includes(otp)).toBe(true);
+        expect(text.includes(code) || html.includes(code)).toBe(true);
 
         await app.stop();
       } finally {

package/src/plugins/auth-methods.security.test.ts

@@ -12,11 +12,10 @@ import { oke } from "../kernel/app.ts";
 import { resetFlowSeq } from "../kernel/flow.ts";
 import { resetBindings } from "../kernel/on.ts";
 import { anonymous } from "./anonymous.ts";
-import { emailOtp } from "./email-otp.ts";
 import { magicLink } from "./magic-link.ts";
+import { otp } from "./otp.ts";
 import { passkey } from "./passkey.ts";
 import { b64urlEncode, buildAuthenticatorData, signWebAuthnAssertion } from "./passkey-webauthn.ts";
-import { phoneNumber } from "./phone-number.ts";
 import { twoFactor, verifyTotp, createTwoFactorStore } from "./two-factor.ts";
 import { username } from "./username.ts";
 
@@ -51,8 +50,7 @@ function fullAuthApp() {
     .plug(username())
     .plug(anonymous())
     .plug(magicLink({ exposeDevToken: true }))
-    .plug(emailOtp({ exposeDevOtp: true }))
-    .plug(phoneNumber({ exposeDevOtp: true }))
+    .plug(otp({ tier: 2, channels: ["email", "sms"], exposeDevOtp: true }))
     .plug(twoFactor())
     .plug(passkey({ origins: ["http://localhost"] }));
 }
@@ -141,8 +139,7 @@ describe("auth methods — rate limiting / enumeration", () => {
 
     const paths: Array<{ path: string; body: unknown }> = [
       { path: "/auth/magic-link/request", body: { email: "r@example.com" } },
-      { path: "/auth/email-otp/request", body: { email: "r@example.com" } },
-      { path: "/auth/phone/request", body: { phone: "+15551234567" } },
+      { path: "/auth/otp/request", body: { email: "r@example.com" } },
       { path: "/auth/passkey/authenticate/options", body: {} },
     ];
 
@@ -225,14 +222,14 @@ describe("auth methods — single-use OTP / token / backup codes", () => {
     const app = fullAuthApp();
     await app.boot({ env: "test" });
 
-    const req = await app.fetch(jsonPost("/auth/email-otp/request", { email: "otp@example.com" }));
+    const req = await app.fetch(jsonPost("/auth/otp/request", { email: "otp@example.com" }));
     const { data } = (await req.json()) as { data: { devOtp: string } };
     const first = await app.fetch(
-      jsonPost("/auth/email-otp/verify", { email: "otp@example.com", otp: data.devOtp }),
+      jsonPost("/auth/otp/verify", { email: "otp@example.com", otp: data.devOtp }),
     );
     expect(first.status).toBe(200);
     const reuse = await app.fetch(
-      jsonPost("/auth/email-otp/verify", { email: "otp@example.com", otp: data.devOtp }),
+      jsonPost("/auth/otp/verify", { email: "otp@example.com", otp: data.devOtp }),
     );
     expect((await readError(reuse)).reason).toBe("invalid_credentials");
 
@@ -243,14 +240,14 @@ describe("auth methods — single-use OTP / token / backup codes", () => {
     const app = fullAuthApp();
     await app.boot({ env: "test" });
 
-    const req = await app.fetch(jsonPost("/auth/phone/request", { phone: "+15559876543" }));
+    const req = await app.fetch(jsonPost("/auth/otp/request", { phone: "+15559876543" }));
     const { data } = (await req.json()) as { data: { devOtp: string } };
     const first = await app.fetch(
-      jsonPost("/auth/phone/verify", { phone: "+15559876543", otp: data.devOtp }),
+      jsonPost("/auth/otp/verify", { phone: "+15559876543", otp: data.devOtp }),
     );
     expect(first.status).toBe(200);
     const reuse = await app.fetch(
-      jsonPost("/auth/phone/verify", { phone: "+15559876543", otp: data.devOtp }),
+      jsonPost("/auth/otp/verify", { phone: "+15559876543", otp: data.devOtp }),
     );
     expect((await readError(reuse)).reason).toBe("invalid_credentials");
 
@@ -421,7 +418,7 @@ describe("auth methods — anonymous non-escalation", () => {
 });
 
 describe("auth methods — channel delivery", () => {
-  test("magic / email-otp send via fx.send; phone remains unwired; exposeDev* stays off by default", async () => {
+  test("magic uses fx.send; otp Tier 2 uses fx.deliverOtp; exposeDev* stays off by default", async () => {
     resetBindings();
     resetFlowSeq();
     const app = oke({
@@ -431,8 +428,7 @@ describe("auth methods — channel delivery", () => {
       gate: { auth: { secret: SECRET, emailAndPassword: { enabled: true } } },
     })
       .plug(magicLink())
-      .plug(emailOtp())
-      .plug(phoneNumber());
+      .plug(otp({ tier: 2, channels: ["email", "sms"] }));
     await app.boot({ env: "test" });
 
     const ml = await app.fetch(jsonPost("/auth/magic-link/request", { email: "x@example.com" }));
@@ -440,27 +436,24 @@ describe("auth methods — channel delivery", () => {
     expect(mlBody.data.ok).toBe(true);
     expect(mlBody.data.devToken).toBeUndefined();
 
-    const otp = await app.fetch(jsonPost("/auth/email-otp/request", { email: "x@example.com" }));
-    const otpBody = (await otp.json()) as { data: Record<string, unknown> };
+    const otpRes = await app.fetch(jsonPost("/auth/otp/request", { email: "x@example.com" }));
+    const otpBody = (await otpRes.json()) as { data: Record<string, unknown> };
     expect(otpBody.data.ok).toBe(true);
     expect(otpBody.data.devOtp).toBeUndefined();
 
-    const phone = await app.fetch(jsonPost("/auth/phone/request", { phone: "+15551112222" }));
+    const phone = await app.fetch(jsonPost("/auth/otp/request", { phone: "+15551112222" }));
     const phoneBody = (await phone.json()) as { data: Record<string, unknown> };
     expect(phoneBody.data.ok).toBe(true);
     expect(phoneBody.data.devOtp).toBeUndefined();
 
     const magicSrc = await Bun.file(new URL("./magic-link.ts", import.meta.url)).text();
-    const emailSrc = await Bun.file(new URL("./email-otp.ts", import.meta.url)).text();
-    const phoneSrc = await Bun.file(new URL("./phone-number.ts", import.meta.url)).text();
-    expect(magicSrc).toMatch(/fx\.send/);
+    const otpSrc = await Bun.file(new URL("./otp.ts", import.meta.url)).text();
+    expect(magicSrc).toMatch(/fx\.send\(/);
     expect(magicSrc).toMatch(/channel\./);
-    expect(emailSrc).toMatch(/fx\.send/);
-    expect(emailSrc).toMatch(/channel\./);
-    // SMS delivery stays deferred — phone must not import Channel or fx.send.
-    expect(phoneSrc).not.toMatch(/fx\.send/);
-    expect(phoneSrc).not.toMatch(/channel\./);
-    expect(phoneSrc).not.toMatch(/from ["'].*channel/);
+    expect(otpSrc).toMatch(/fx\s*\.\s*deliverOtp/);
+    expect(otpSrc).toMatch(/fx\s*\.\s*sendOtp/);
+    expect(otpSrc).toMatch(/fx\s*\.\s*verifyOtp/);
+    expect(otpSrc).not.toMatch(/taqnyat-sms|sently\/transports/);
 
     await app.stop();
   });

package/src/plugins/auth-methods.test.ts

@@ -7,8 +7,8 @@ import { oke } from "../kernel/app.ts";
 import { resetFlowSeq } from "../kernel/flow.ts";
 import { resetBindings } from "../kernel/on.ts";
 import { anonymous } from "./anonymous.ts";
-import { emailOtp } from "./email-otp.ts";
 import { magicLink } from "./magic-link.ts";
+import { otp } from "./otp.ts";
 import { username } from "./username.ts";
 
 afterEach(() => {
@@ -31,7 +31,7 @@ function authApp() {
     .plug(username())
     .plug(anonymous())
     .plug(magicLink({ exposeDevToken: true }))
-    .plug(emailOtp({ exposeDevOtp: true }));
+    .plug(otp({ tier: 2, channels: ["email"], exposeDevOtp: true }));
 }
 
 describe("auth method plugins", () => {
@@ -42,8 +42,9 @@ describe("auth method plugins", () => {
     expect(app.router.match("POST", "/auth/sign-in/anonymous")).toBeTruthy();
     expect(app.router.match("POST", "/auth/magic-link/request")).toBeTruthy();
     expect(app.router.match("POST", "/auth/magic-link/verify")).toBeTruthy();
-    expect(app.router.match("POST", "/auth/email-otp/request")).toBeTruthy();
-    expect(app.router.match("POST", "/auth/email-otp/verify")).toBeTruthy();
+    expect(app.router.match("POST", "/auth/otp/request")).toBeTruthy();
+    expect(app.router.match("POST", "/auth/otp/verify")).toBeTruthy();
+    expect(app.router.match("POST", "/auth/otp/resend")).toBeTruthy();
     await app.boot({ env: "test" });
     await app.stop();
   });
@@ -147,7 +148,7 @@ describe("auth method plugins", () => {
     await app.boot({ env: "test" });
 
     const req = await app.fetch(
-      new Request("http://localhost/auth/email-otp/request", {
+      new Request("http://localhost/auth/otp/request", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ email: "otp@example.com" }),
@@ -158,7 +159,7 @@ describe("auth method plugins", () => {
     expect(requested.data.devOtp).toMatch(/^\d{6}$/);
 
     const verify = await app.fetch(
-      new Request("http://localhost/auth/email-otp/verify", {
+      new Request("http://localhost/auth/otp/verify", {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({

package/src/plugins/index.ts

@@ -15,8 +15,6 @@ export {
   type ConfigSourceOptions,
 } from "./config-source.ts";
 export { cors, type CorsOptions } from "./cors.ts";
-export { csrf, type CsrfOptions } from "./csrf.ts";
-export { emailOtp, emailOtpCatalog, emailOtpTemplate, type EmailOtpOptions } from "./email-otp.ts";
 export { ipAllowlist, type IpAllowlistOptions } from "./ip-allowlist.ts";
 export {
   magicLink,
@@ -25,6 +23,18 @@ export {
   type MagicLinkOptions,
 } from "./magic-link.ts";
 export { maintenanceMode, type MaintenanceModeOptions } from "./maintenance-mode.ts";
+export {
+  createPhoneStore,
+  otp,
+  otpCatalog,
+  otpEmailTemplate,
+  otpSmsTemplate,
+  otpWhatsappTemplate,
+  type OtpOptions,
+  type OtpTier1Options,
+  type OtpTier2Options,
+  type PhoneStore,
+} from "./otp.ts";
 export {
   createPasskeyStore,
   passkey,
@@ -40,12 +50,6 @@ export {
   verifyWebAuthnCeremony,
   type WebAuthnVerifyOptions,
 } from "./passkey-webauthn.ts";
-export {
-  createPhoneStore,
-  phoneNumber,
-  type PhoneNumberOptions,
-  type PhoneStore,
-} from "./phone-number.ts";
 export {
   defaultCspDirectives,
   headers,