@nxgt/janus 0.4.0 → 0.6.0

package/dist/index.js

@@ -5,13 +5,13 @@ import {
   MAX_PAGE_SIZE2,
   pageLimit2,
   invalidCursor2
-} from "./chunks/index-53y1afjz.js";
+} from "./chunks/index-5vr13kkb.js";
 import {
   mintId2,
   isId2,
   mintedAt2,
   createMemoryStores2
-} from "./chunks/index-thtyq7a9.js";
+} from "./chunks/index-gbwn2tts.js";
 import {
   JanusError2,
   StoreFailure2,
@@ -21,6 +21,7 @@ import {
   CredentialError2,
   UserInactiveError2,
   TokenError2,
+  SecondFactorError2,
   InvalidCursorError2,
   UnsupportedError2,
   PermissionDepthError2,
@@ -33,7 +34,7 @@ import {
   formatTuple2,
   parseTuple2,
   parseSubject2
-} from "./chunks/index-qwfkhqkk.js";
+} from "./chunks/index-06vp9c5r.js";
 
 // src/auth/hashers.ts
 import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
@@ -140,6 +141,69 @@ function parseDuration(value, where) {
   return ms;
 }
 
+// src/auth/sealing.ts
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2 } from "node:crypto";
+var TAG_BYTES = 16;
+var KEY_ID = /^[A-Za-z0-9_-]{1,64}$/;
+var KEY = /^[A-Za-z0-9+/_-]{43}=?$/;
+function resolveSealer(keys, where) {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    throw new TypeError(`${where}: expected at least one key — [{ id, key }], the first seals`);
+  }
+  const decoded = new Map;
+  for (const entry of keys) {
+    const id = entry?.id;
+    if (typeof id !== "string" || !KEY_ID.test(id)) {
+      throw new TypeError(`${where}: every key needs an id of letters, digits, _ and -, at most 64 of them`);
+    }
+    if (decoded.has(id)) {
+      throw new TypeError(`${where}: two keys have the id "${id}"`);
+    }
+    const key = entry.key;
+    if (typeof key !== "string" || !KEY.test(key)) {
+      throw new TypeError(`${where}: the key "${id}" is not 32 bytes in base64 — make one with openssl rand -base64 32`);
+    }
+    decoded.set(id, Buffer.from(key, "base64"));
+  }
+  return { sealWith: keys[0].id, keys: decoded };
+}
+function seal(sealer, plain, boundTo) {
+  const key = sealer.keys.get(sealer.sealWith);
+  const iv = randomBytes2(12);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  cipher.setAAD(Buffer.from(boundTo));
+  const sealed = Buffer.concat([
+    cipher.update(plain, "utf8"),
+    cipher.final(),
+    cipher.getAuthTag()
+  ]);
+  return `v1.${sealer.sealWith}.${iv.toString("base64url")}.${sealed.toString("base64url")}`;
+}
+function unseal(sealer, sealed, boundTo, where) {
+  const parts = sealed.split(".");
+  const [version, keyId, iv, body] = parts;
+  const bytes = Buffer.from(body ?? "", "base64url");
+  if (parts.length !== 4 || version !== "v1" || keyId === undefined || iv === undefined || bytes.length <= TAG_BYTES) {
+    throw new TypeError(`${where}: the stored secret is not a sealed one`);
+  }
+  const key = sealer.keys.get(keyId);
+  if (key === undefined) {
+    throw new TypeError(`${where}: the secret is sealed with the key "${keyId}", which secondFactor.keys no longer holds — keep a key until no secret is sealed with it`);
+  }
+  try {
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "base64url"), { authTagLength: TAG_BYTES });
+    decipher.setAAD(Buffer.from(boundTo));
+    decipher.setAuthTag(bytes.subarray(bytes.length - TAG_BYTES));
+    const plain = Buffer.concat([
+      decipher.update(bytes.subarray(0, bytes.length - TAG_BYTES)),
+      decipher.final()
+    ]).toString("utf8");
+    return { plain, keyId };
+  } catch (cause) {
+    throw new TypeError(`${where}: the secret does not open with the key "${keyId}" — was that key changed under the same id, or the secret copied from another user?`, { cause });
+  }
+}
+
 // src/auth/config.ts
 var SINGLE_TYPE = "user";
 var RESERVED_FIELDS = [
@@ -148,6 +212,7 @@ var RESERVED_FIELDS = [
   "emailVerified",
   "active",
   "hasPassword",
+  "hasSecondFactor",
   "version",
   "createdAt",
   "updatedAt",
@@ -213,9 +278,24 @@ function resolveConfig(config, where) {
     types,
     tokenTtlMs: {
       verifyEmail: parseDuration(config.tokens?.verifyEmail ?? "24h", `${where}: tokens.verifyEmail`),
-      resetPassword: parseDuration(config.tokens?.resetPassword ?? "1h", `${where}: tokens.resetPassword`)
+      resetPassword: parseDuration(config.tokens?.resetPassword ?? "1h", `${where}: tokens.resetPassword`),
+      signInCode: parseDuration(config.tokens?.signInCode ?? "10m", `${where}: tokens.signInCode`)
     },
-    cookie: resolveCookie(config.cookie ?? {}, where)
+    cookie: resolveCookie(config.cookie ?? {}, where),
+    secondFactor: resolveSecondFactor(config.secondFactor, where)
+  };
+}
+function resolveSecondFactor(config, where) {
+  if (config === undefined)
+    return null;
+  const at = `${where}: secondFactor`;
+  if (typeof config?.issuer !== "string" || config.issuer.trim() === "") {
+    throw new TypeError(`${at}.issuer must name your application — the authenticator app shows it beside the account`);
+  }
+  return {
+    issuer: config.issuer,
+    sealer: resolveSealer(config.keys, `${at}.keys`),
+    challengeTtlMs: parseDuration(config.challenge ?? "5m", `${at}.challenge`)
   };
 }
 function resolveType(name, type, at, schemaKey) {
@@ -336,6 +416,7 @@ function toUser(record) {
     emailVerified: record.emailVerifiedAt !== null,
     active: record.active,
     hasPassword: record.password !== null,
+    hasSecondFactor: record.secondFactor?.confirmedAt != null,
     version: record.version,
     createdAt: record.createdAt,
     updatedAt: record.updatedAt
@@ -499,6 +580,14 @@ async function writeUser(context, user, type, options, where, patchOf) {
   const patch = await patchOf(record, now);
   return context.store.users.updateUser(record.id, { ...patch, updatedAt: now }, record.version);
 }
+async function holderOfEmail(context, type, email) {
+  const wanted = normalizeEmail(email);
+  if (!isStorable(wanted))
+    return null;
+  const record = await context.store.users.findUserByLogin(type.name, wanted);
+  const held = record === null ? null : emailOf(type, record.fields);
+  return held !== null && normalizeEmail(held) === wanted ? record : null;
+}
 
 // src/auth/port/assert-stores.ts
 var REQUIRED = {
@@ -544,9 +633,9 @@ function assertStores(stores, where) {
 }
 
 // src/auth/secrets.ts
-import { createHash, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash, randomBytes as randomBytes3 } from "node:crypto";
 function mintSecret() {
-  return randomBytes2(32).toString("base64url");
+  return randomBytes3(32).toString("base64url");
 }
 function hashSecret(secret) {
   return createHash("sha256").update(secret).digest("hex");
@@ -570,7 +659,12 @@ async function openSession(context, type, user) {
     createdAt: now
   };
   await context.store.sessions.insertSession(record);
-  return { user: toUser(user), session: toSession(record), token };
+  return {
+    status: "signedIn",
+    user: toUser(user),
+    session: toSession(record),
+    token
+  };
 }
 function sharedApi(context) {
   const { store, clock, config } = context;
@@ -696,10 +790,373 @@ function headersOf(request) {
   return request;
 }
 
+// src/auth/one-time.ts
+import { randomInt, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+var CODE_ATTEMPTS = 5;
+async function countCodeAttempt(context, secret, kind, where, userType) {
+  const token = await context.store.tokens.countAttempt(hashSecret(secret), kind);
+  refuseUnusable(token, context.clock.now(), where, "challenge");
+  if (token.attempts > CODE_ATTEMPTS) {
+    throw codeInvalid(where, token.userId, userType, 0);
+  }
+  return { token, attemptsLeft: CODE_ATTEMPTS - token.attempts };
+}
+function codeInvalid(where, userId, userType, attemptsLeft) {
+  return new TokenError2("CODE_INVALID", `${where}: the code does not match, or was already used`, {
+    operation: where,
+    userId,
+    userType,
+    ...attemptsLeft === undefined ? {} : { attemptsLeft }
+  });
+}
+function refuseStale(type, user, token, where, noun) {
+  const email = emailOf(type, user.fields);
+  if (email === null || normalizeEmail(email) !== normalizeEmail(token.address)) {
+    throw new TokenError2("TOKEN_STALE", `${where}: the ${noun} was sent to an e-mail the user no longer has`, { operation: where, userId: user.id, userType: type.name });
+  }
+}
+function refuseUnusable(token, now, where, noun) {
+  if (token === null) {
+    throw new TokenError2("TOKEN_UNKNOWN", `${where}: no such ${noun}`, {
+      operation: where
+    });
+  }
+  if (token.spentAt !== null) {
+    throw new TokenError2("TOKEN_SPENT", `${where}: the ${noun} was already used`, { operation: where });
+  }
+  if (token.expiresAt.getTime() <= now.getTime()) {
+    throw new TokenError2("TOKEN_EXPIRED", `${where}: the ${noun} has expired`, {
+      operation: where
+    });
+  }
+}
+var unknownOneTime = (where, noun) => new TokenError2("TOKEN_UNKNOWN", `${where}: no such ${noun}`, {
+  operation: where
+});
+async function spendOneTime(context, secret, kind, where, noun) {
+  const now = context.clock.now();
+  const token = await context.store.tokens.consumeToken(hashSecret(secret), kind, now);
+  refuseUnusable(token, now, where, noun);
+  return token;
+}
+async function burnOneTime(context, secret, kind) {
+  await context.store.tokens.consumeToken(hashSecret(secret), kind, context.clock.now());
+}
+var hashCode = (challenge, code) => hashSecret(`${challenge}${code}`);
+function codeMatches(token, challenge, code) {
+  if (token.codeHash === null || !/^\d{6}$/.test(code))
+    return false;
+  const given = Buffer.from(hashCode(challenge, code));
+  const held = Buffer.from(token.codeHash);
+  return given.length === held.length && timingSafeEqual2(given, held);
+}
+async function issueOneTime(context, token) {
+  return insertOneTime(context, token, null);
+}
+async function issueCode(context, token) {
+  const code = String(randomInt(1e6)).padStart(6, "0");
+  return { ...await insertOneTime(context, token, code), code };
+}
+async function insertOneTime(context, token, code) {
+  const now = context.clock.now();
+  const secret = mintSecret();
+  const expiresAt = new Date(now.getTime() + token.ttlMs);
+  await context.store.tokens.insertToken({
+    tokenHash: hashSecret(secret),
+    kind: token.kind,
+    userId: token.userId,
+    address: token.address,
+    codeHash: code === null ? null : hashCode(secret, code),
+    attempts: 0,
+    expiresAt,
+    spentAt: null,
+    createdAt: now
+  });
+  return { secret, expiresAt };
+}
+
+// src/auth/totp.ts
+import { createHmac, randomBytes as randomBytes4 } from "node:crypto";
+var TOTP = { digits: 6, stepMs: 30000, drift: 1 };
+var BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+function mintTotpSecret() {
+  return toBase32(randomBytes4(20));
+}
+function toBase32(bytes) {
+  let bits = 0;
+  let value = 0;
+  let out = "";
+  for (const byte of bytes) {
+    value = value << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      out += BASE32[value >>> bits - 5 & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0)
+    out += BASE32[value << 5 - bits & 31];
+  return out;
+}
+function fromBase32(text) {
+  let bits = 0;
+  let value = 0;
+  const out = [];
+  for (const char of text) {
+    const index = BASE32.indexOf(char);
+    if (index === -1)
+      throw new TypeError("totp: the secret is not base32");
+    value = value << 5 | index;
+    bits += 5;
+    if (bits >= 8) {
+      out.push(value >>> bits - 8 & 255);
+      bits -= 8;
+    }
+  }
+  return Buffer.from(out);
+}
+var stepAt = (now) => Math.floor(now.getTime() / TOTP.stepMs);
+function codeAt(secret, step) {
+  const counter = Buffer.alloc(8);
+  counter.writeBigUInt64BE(BigInt(step));
+  const digest = createHmac("sha1", secret).update(counter).digest();
+  const offset = digest[19] & 15;
+  const binary = digest.readUInt32BE(offset) & 2147483647;
+  return String(binary % 10 ** TOTP.digits).padStart(TOTP.digits, "0");
+}
+function matchStep(secret, code, now, lastStep) {
+  if (!/^\d{6}$/.test(code))
+    return null;
+  const current = stepAt(now);
+  let matched = null;
+  for (let step = current - TOTP.drift;step <= current + TOTP.drift; step++) {
+    const fresh = lastStep === null || step > lastStep;
+    if (equalCodes(codeAt(secret, step), code) && fresh && matched === null) {
+      matched = step;
+    }
+  }
+  return matched;
+}
+function equalCodes(a, b) {
+  let difference = a.length ^ b.length;
+  for (let i = 0;i < a.length; i++) {
+    difference |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return difference === 0;
+}
+function otpauthUri(issuer, account, secret) {
+  const label = `${encodeURIComponent(issuer)}:${encodeURIComponent(account)}`;
+  const query = new URLSearchParams({
+    secret,
+    issuer,
+    algorithm: "SHA1",
+    digits: String(TOTP.digits),
+    period: String(TOTP.stepMs / 1000)
+  });
+  return `otpauth://totp/${label}?${query}`;
+}
+
+// src/auth/second-factor/factor.ts
+var isActive = (factor) => factor !== null && factor.confirmedAt !== null;
+function requireSettings(context, where, why) {
+  const configured = context.config.secondFactor;
+  if (configured === null) {
+    throw new TypeError(`${where}: ${why}, and janus() was given no secondFactor — pass secondFactor: { issuer, keys }`);
+  }
+  return configured;
+}
+function acceptCode(configured, record, factor, code, now, where) {
+  const { plain, keyId } = unseal(configured.sealer, factor.secret, record.id, where);
+  const step = matchStep(fromBase32(plain), code, now, factor.lastStep);
+  if (step === null)
+    return null;
+  return {
+    ...factor,
+    lastStep: step,
+    secret: keyId === configured.sealer.sealWith ? factor.secret : seal(configured.sealer, plain, record.id)
+  };
+}
+
+// src/auth/second-factor/challenge.ts
+function challengeFlows(context, type, at) {
+  const { store, clock } = context;
+  const spend = (challenge, where) => spendOneTime(context, challenge, "secondFactor", where, "challenge");
+  return {
+    async issue(record, where) {
+      const configured = requireSettings(context, where, "the user's second factor is active");
+      const { secret, expiresAt } = await issueOneTime(context, {
+        kind: "secondFactor",
+        userId: record.id,
+        address: "",
+        ttlMs: configured.challengeTtlMs
+      });
+      return { status: "secondFactor", challenge: secret, expiresAt };
+    },
+    async confirm(challenge, code) {
+      const where = at("secondFactor.confirm");
+      const configured = requireSettings(context, where, "a second factor is being confirmed");
+      const secret = String(challenge);
+      const { token, attemptsLeft } = await countCodeAttempt(context, secret, "secondFactor", where, type.name);
+      const record = await findRecord(context, token.userId, type.name);
+      if (record === null)
+        throw unknownOneTime(where, "challenge");
+      if (!record.active) {
+        await spend(secret, where);
+        throw new UserInactiveError2(`${where}: the user is inactive`, {
+          userId: record.id,
+          userType: type.name
+        });
+      }
+      if (!isActive(record.secondFactor)) {
+        await spend(secret, where);
+        throw new SecondFactorError2("SECOND_FACTOR_NOT_ENROLLED", `${where}: the user no longer has a second factor — sign in again`, { operation: where, userId: record.id, userType: type.name });
+      }
+      const now = clock.now();
+      const accepted = acceptCode(configured, record, record.secondFactor, String(code), now, where);
+      if (accepted === null) {
+        if (attemptsLeft === 0) {
+          await burnOneTime(context, secret, "secondFactor");
+        }
+        throw codeInvalid(where, record.id, type.name, attemptsLeft);
+      }
+      const written = await store.users.updateUser(record.id, { secondFactor: accepted, updatedAt: now }, record.version);
+      await spend(secret, where);
+      return openSession(context, type, written);
+    }
+  };
+}
+
+// src/auth/second-factor/lifecycle.ts
+function lifecycleFlows(context, type, at) {
+  const accountOf = (record, where) => {
+    if (type.password === null) {
+      throw new TypeError(`${where}: the ${type.name} type does not sign in with a password, so it has no second factor`);
+    }
+    return String(record.fields[type.password.login]);
+  };
+  const refuse = (code, message, where, record) => new SecondFactorError2(code, `${where}: ${message}`, {
+    operation: where,
+    userId: record.id,
+    userType: type.name
+  });
+  return {
+    async enroll(user, options) {
+      const where = at("secondFactor.enroll");
+      const configured = requireSettings(context, where, "a second factor is being enrolled");
+      const secret = mintTotpSecret();
+      const written = await writeUser(context, user, type, options, where, (record) => {
+        if (isActive(record.secondFactor)) {
+          throw refuse("SECOND_FACTOR_ACTIVE", "the user's second factor is active — disable it first", where, record);
+        }
+        accountOf(record, where);
+        return {
+          secondFactor: {
+            method: "totp",
+            secret: seal(configured.sealer, secret, record.id),
+            confirmedAt: null,
+            lastStep: null
+          }
+        };
+      });
+      return {
+        secret,
+        uri: otpauthUri(configured.issuer, accountOf(written, where), secret)
+      };
+    },
+    async activate(user, code, options) {
+      const where = at("secondFactor.activate");
+      const configured = requireSettings(context, where, "a second factor is being activated");
+      const written = await writeUser(context, user, type, options, where, (record, now) => {
+        const factor = record.secondFactor;
+        if (factor === null) {
+          throw refuse("SECOND_FACTOR_NOT_ENROLLED", "the user has no second factor waiting — call enroll first", where, record);
+        }
+        if (isActive(factor)) {
+          throw refuse("SECOND_FACTOR_ACTIVE", "the user's second factor is already active", where, record);
+        }
+        const accepted = acceptCode(configured, record, factor, String(code), now, where);
+        if (accepted === null)
+          throw codeInvalid(where, record.id, type.name);
+        return { secondFactor: { ...accepted, confirmedAt: now } };
+      });
+      return toUser(written);
+    },
+    async disable(user, options) {
+      const where = at("secondFactor.disable");
+      return toUser(await writeUser(context, user, type, options, where, () => ({
+        secondFactor: null
+      })));
+    }
+  };
+}
+
+// src/auth/second-factor/flows.ts
+function secondFactorFlows(context, type, at) {
+  const challenges = challengeFlows(context, type, at);
+  const api = {
+    ...lifecycleFlows(context, type, at),
+    confirm: challenges.confirm
+  };
+  return {
+    api,
+    finish: (record, where) => isActive(record.secondFactor) ? challenges.issue(record, where) : openSession(context, type, record)
+  };
+}
+
+// src/auth/sign-in-code.ts
+function signInCodeFlows(context, type, at, finish) {
+  return {
+    async request(email) {
+      const record = await holderOfEmail(context, type, String(email));
+      if (record === null || !record.active)
+        return null;
+      const { secret, code, expiresAt } = await issueCode(context, {
+        kind: "signInCode",
+        userId: record.id,
+        address: String(record.fields[type.email]),
+        ttlMs: context.config.tokenTtlMs.signInCode
+      });
+      return {
+        code,
+        challenge: secret,
+        email: String(record.fields[type.email]),
+        expiresAt,
+        user: toUser(record)
+      };
+    },
+    async confirm(challenge, code) {
+      const where = at("signInCode.confirm");
+      const secret = String(challenge);
+      const { token, attemptsLeft } = await countCodeAttempt(context, secret, "signInCode", where, type.name);
+      const user = await findRecord(context, token.userId, type.name);
+      if (user === null)
+        throw unknownOneTime(where, "challenge");
+      if (!codeMatches(token, secret, String(code))) {
+        if (token.attempts === CODE_ATTEMPTS) {
+          await burnOneTime(context, secret, "signInCode");
+        }
+        throw codeInvalid(where, user.id, type.name, attemptsLeft);
+      }
+      await spendOneTime(context, secret, "signInCode", where, "challenge");
+      refuseStale(type, user, token, where, "code");
+      if (!user.active) {
+        throw new UserInactiveError2(`${where}: the user is inactive`, {
+          userId: user.id,
+          userType: type.name
+        });
+      }
+      const proved = user.emailVerifiedAt === null ? await writeUser(context, user.id, type, { ifVersion: user.version }, where, (_, now) => ({ emailVerifiedAt: now })) : user;
+      return finish(proved, where);
+    }
+  };
+}
+
 // src/auth/users.ts
 function typeApi(context, type) {
   const { store, clock } = context;
   const at = (operation) => context.config.single ? operation : `${type.name}.${operation}`;
+  const secondFactor = secondFactorFlows(context, type, at);
+  const signInCode = signInCodeFlows(context, type, at, secondFactor.finish);
   const byLogin = async (login) => isStorable(login) ? store.users.findUserByLogin(type.name, login) : null;
   const insert = async (input, where) => {
     const { password, active, ...rest } = input ?? {};
@@ -729,33 +1186,11 @@ function typeApi(context, type) {
     });
   };
   const redeem = async (kind, secret, where) => {
-    const now = clock.now();
-    const token = await store.tokens.consumeToken(hashSecret(secret), kind, now);
-    if (token === null) {
-      throw new TokenError2("TOKEN_UNKNOWN", `${where}: no such token`, {
-        operation: where
-      });
-    }
-    if (token.spentAt !== null) {
-      throw new TokenError2("TOKEN_SPENT", `${where}: the token was already used`, {
-        operation: where
-      });
-    }
-    if (token.expiresAt.getTime() <= now.getTime()) {
-      throw new TokenError2("TOKEN_EXPIRED", `${where}: the token has expired`, {
-        operation: where
-      });
-    }
+    const token = await spendOneTime(context, secret, kind, where, "token");
     const user = await findRecord(context, token.userId, type.name);
-    if (user === null) {
-      throw new TokenError2("TOKEN_UNKNOWN", `${where}: no such token`, {
-        operation: where
-      });
-    }
-    const email = emailOf(type, user.fields);
-    if (email === null || normalizeEmail(email) !== normalizeEmail(token.address)) {
-      throw new TokenError2("TOKEN_STALE", `${where}: the token was sent to an e-mail the user no longer has`, { operation: where, userId: user.id, userType: type.name });
-    }
+    if (user === null)
+      throw unknownOneTime(where, "token");
+    refuseStale(type, user, token, where, "token");
     return { token, user };
   };
   const issue = async (kind, user, where) => {
@@ -767,19 +1202,11 @@ function typeApi(context, type) {
         operation: where
       });
     }
-    const now = clock.now();
-    const secret = mintSecret();
-    const expiresAt = new Date(now.getTime() + context.config.tokenTtlMs[kind]);
-    await store.tokens.insertToken({
-      tokenHash: hashSecret(secret),
+    const { secret, expiresAt } = await issueOneTime(context, {
       kind,
       userId: user.id,
       address: email,
-      codeHash: null,
-      attempts: 0,
-      expiresAt,
-      spentAt: null,
-      createdAt: now
+      ttlMs: context.config.tokenTtlMs[kind]
     });
     return { token: secret, email, expiresAt };
   };
@@ -876,7 +1303,7 @@ function typeApi(context, type) {
           userType: type.name
         });
       }
-      return openSession(context, type, await rehashed(context, record, String(password)));
+      return secondFactor.finish(await rehashed(context, record, String(password)), where);
     },
     async findByLogin(login) {
       const rule = passwordRule(at("findByLogin"));
@@ -913,6 +1340,8 @@ function typeApi(context, type) {
         };
       }));
     },
+    secondFactor: secondFactor.api,
+    signInCode,
     verifyEmail: {
       async send(user) {
         const where = at("verifyEmail.send");
@@ -931,12 +1360,9 @@ function typeApi(context, type) {
       async request(email) {
         const where = at("resetPassword.request");
         passwordRule(where);
-        const wanted = normalizeEmail(String(email));
-        const record = await byLogin(wanted);
-        const held = record === null ? null : emailOf(type, record.fields);
-        if (record === null || held === null || normalizeEmail(held) !== wanted) {
+        const record = await holderOfEmail(context, type, String(email));
+        if (record === null)
           return null;
-        }
         const issued = await issue("resetPassword", record, where);
         return { ...issued, user: toUser(record) };
       },
@@ -998,6 +1424,7 @@ export {
   MAX_PAGE_SIZE2 as MAX_PAGE_SIZE,
   NotFoundError2 as NotFoundError,
   PermissionDepthError2 as PermissionDepthError,
+  SecondFactorError2 as SecondFactorError,
   StoreConflict2 as StoreConflict,
   StoreFailure2 as StoreFailure,
   TokenError2 as TokenError,
@@ -1028,5 +1455,5 @@ export {
   systemClock
 };
 
-//# debugId=0C2151B9E5FBCB0864756E2164756E21
+//# debugId=9A2F9DDAD478673A64756E2164756E21
 //# sourceMappingURL=index.js.map