@hartl-services/medusa-base 2.6.1 → 2.7.0

package/dist/customer-auth/customer-auth-methods-snapshot.d.ts

@@ -0,0 +1,25 @@
+/** Reads the switches once; never rejects. Concurrent calls share one read. */
+export declare const refreshCustomerAuthMethodsSnapshot: () => Promise<void>;
+/** Stops the periodic refresh (application shutdown). The value stays. */
+export declare const stopCustomerAuthMethodsSnapshot: () => void;
+/**
+ * Registers the reader, loads the switches once and keeps them fresh every
+ * 30 s (application start). `read` returns the effective feature map of
+ * `customer_auth`; `warn` is the container logger.
+ */
+export declare const startCustomerAuthMethodsSnapshot: (input: Readonly<{
+    read: () => Promise<Readonly<Record<string, boolean>>>;
+    warn: (message: string) => void;
+}>) => Promise<void>;
+/**
+ * The value of `authMethodsPerActor.customer`: the provider ids a customer
+ * may use. Synchronous; starts a background refresh when the copy is stale.
+ * A fresh array per call.
+ */
+export declare const customerAuthMethods: () => string[];
+/**
+ * Test hook: sets the methods and counts as just refreshed, so they hold for
+ * 30 s without a reader; `null` forgets reader and value (back to the
+ * defaults).
+ */
+export declare const setCustomerAuthMethodsForTests: (methods: readonly string[] | null) => void;

package/dist/customer-auth/customer-auth-methods-snapshot.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCustomerAuthMethodsForTests = exports.customerAuthMethods = exports.startCustomerAuthMethodsSnapshot = exports.stopCustomerAuthMethodsSnapshot = exports.refreshCustomerAuthMethodsSnapshot = void 0;
+const refreshing_snapshot_1 = require("../shared/lib/refreshing-snapshot");
+const auth_methods_1 = require("./domain/auth-methods");
+const plugin_features_1 = require("./plugin-features");
+/**
+ * In-memory copy of the login methods customers may use, for the one place
+ * that cannot await them: Medusa reads
+ * `projectConfig.http.authMethodsPerActor.customer` synchronously on every
+ * request to an `/auth/customer/<provider>` route. The shop preset puts
+ * `customerAuthMethods()` behind a getter there, so a switch in the Admin
+ * takes effect without a restart. Loading, the 30 s refresh and the failure
+ * behavior are those of `createRefreshingSnapshot`.
+ *
+ * Start and fallback value are the descriptor defaults (`["emailpass"]`),
+ * never an empty list: an empty allowlist blocks every customer login, so a
+ * failed read must not produce one.
+ */
+const snapshot = (0, refreshing_snapshot_1.createRefreshingSnapshot)({
+    key: "@hartl-services/medusa-base/customer-auth-methods-snapshot",
+    initial: Object.freeze((0, auth_methods_1.defaultCustomerAuthMethods)(plugin_features_1.customerAuthPluginFeatures)),
+    describe: (methods) => `Customer login methods could not be read, keeping [${methods.join(", ")}]`,
+});
+/** Reads the switches once; never rejects. Concurrent calls share one read. */
+const refreshCustomerAuthMethodsSnapshot = () => snapshot.refresh();
+exports.refreshCustomerAuthMethodsSnapshot = refreshCustomerAuthMethodsSnapshot;
+/** Stops the periodic refresh (application shutdown). The value stays. */
+const stopCustomerAuthMethodsSnapshot = () => snapshot.stop();
+exports.stopCustomerAuthMethodsSnapshot = stopCustomerAuthMethodsSnapshot;
+/**
+ * Registers the reader, loads the switches once and keeps them fresh every
+ * 30 s (application start). `read` returns the effective feature map of
+ * `customer_auth`; `warn` is the container logger.
+ */
+const startCustomerAuthMethodsSnapshot = (input) => snapshot.start({
+    read: async () => Object.freeze((0, auth_methods_1.deriveCustomerAuthMethods)(await input.read())),
+    warn: input.warn,
+});
+exports.startCustomerAuthMethodsSnapshot = startCustomerAuthMethodsSnapshot;
+/**
+ * The value of `authMethodsPerActor.customer`: the provider ids a customer
+ * may use. Synchronous; starts a background refresh when the copy is stale.
+ * A fresh array per call.
+ */
+const customerAuthMethods = () => [...snapshot.current()];
+exports.customerAuthMethods = customerAuthMethods;
+/**
+ * Test hook: sets the methods and counts as just refreshed, so they hold for
+ * 30 s without a reader; `null` forgets reader and value (back to the
+ * defaults).
+ */
+const setCustomerAuthMethodsForTests = (methods) => snapshot.setForTests(methods === null ? null : Object.freeze([...methods]));
+exports.setCustomerAuthMethodsForTests = setCustomerAuthMethodsForTests;

package/dist/customer-auth/domain/auth-methods.d.ts

@@ -0,0 +1,16 @@
+import type { PluginFeatureDescriptor } from "../../public/types";
+/** Medusa's built-in e-mail + password provider. */
+export declare const EMAIL_PASSWORD_AUTH_PROVIDER = "emailpass";
+/**
+ * The auth providers a customer may use for the given effective switches:
+ * `emailpass` while `email_password` is on, `email-otp` while `email_otp` is
+ * on. Empty only when both are off, which blocks every customer login (Medusa
+ * treats an empty allowlist as "nothing allowed"). A fresh array per call.
+ */
+export declare const deriveCustomerAuthMethods: (features: Readonly<Record<string, boolean | undefined>>) => string[];
+/**
+ * The methods of a shop whose switches were never stored: the defaults of
+ * the descriptor. This is the start value and the fallback of the snapshot,
+ * so an unreadable database never locks every customer out.
+ */
+export declare const defaultCustomerAuthMethods: (descriptor: PluginFeatureDescriptor) => string[];

package/dist/customer-auth/domain/auth-methods.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCustomerAuthMethods = exports.deriveCustomerAuthMethods = exports.EMAIL_PASSWORD_AUTH_PROVIDER = void 0;
+const customer_auth_1 = require("@hartl-services/medusa-food-supplements-contracts/schemas/customer-auth");
+/** Medusa's built-in e-mail + password provider. */
+exports.EMAIL_PASSWORD_AUTH_PROVIDER = "emailpass";
+/**
+ * The auth providers a customer may use for the given effective switches:
+ * `emailpass` while `email_password` is on, `email-otp` while `email_otp` is
+ * on. Empty only when both are off, which blocks every customer login (Medusa
+ * treats an empty allowlist as "nothing allowed"). A fresh array per call.
+ */
+const deriveCustomerAuthMethods = (features) => [
+    ...(features[customer_auth_1.CUSTOMER_AUTH_FEATURES.emailPassword] === true
+        ? [exports.EMAIL_PASSWORD_AUTH_PROVIDER]
+        : []),
+    ...(features[customer_auth_1.CUSTOMER_AUTH_FEATURES.emailOtp] === true
+        ? [customer_auth_1.EMAIL_OTP_AUTH_PROVIDER]
+        : []),
+];
+exports.deriveCustomerAuthMethods = deriveCustomerAuthMethods;
+/**
+ * The methods of a shop whose switches were never stored: the defaults of
+ * the descriptor. This is the start value and the fallback of the snapshot,
+ * so an unreadable database never locks every customer out.
+ */
+const defaultCustomerAuthMethods = (descriptor) => (0, exports.deriveCustomerAuthMethods)(Object.fromEntries(descriptor.features.map((feature) => [
+    feature.key,
+    feature.default_enabled,
+])));
+exports.defaultCustomerAuthMethods = defaultCustomerAuthMethods;

package/dist/customer-auth/plugin-features.d.ts

@@ -0,0 +1,2 @@
+export declare const customerAuthPluginFeatures: import("../public").PluginFeatureDescriptor<"email_password" | "email_otp", "password_min_length" | "password_require_mixed_case" | "password_require_digit" | "password_require_symbol", never>;
+export type CustomerAuthFeatureKey = (typeof customerAuthPluginFeatures)["features"][number]["key"];

package/dist/customer-auth/plugin-features.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerAuthPluginFeatures = void 0;
+const customer_auth_1 = require("@hartl-services/medusa-food-supplements-contracts/schemas/customer-auth");
+const descriptor_1 = require("../public/descriptor");
+const PASSWORD_RULES = "Passwort-Regeln";
+exports.customerAuthPluginFeatures = (0, descriptor_1.definePluginFeatures)({
+    plugin_key: customer_auth_1.CUSTOMER_AUTH_PLUGIN_KEY,
+    label: "Kunden-Login",
+    description: "Welche Anmeldemethoden Kunden im Shop nutzen können. Mindestens eine Methode muss eingeschaltet bleiben, sonst kann sich niemand mehr anmelden; Admin-Benutzer melden sich unabhängig davon mit E-Mail und Passwort an. Eine Änderung wirkt innerhalb von etwa 30 Sekunden im Backend, die Storefront übernimmt sie nach ihrem Zwischenspeicher (etwa eine Minute). Die Passwort-Regeln gelten nur für Kunden, solange „E-Mail + Passwort“ eingeschaltet ist; Admin-Benutzer behalten mindestens 15 Zeichen, die bei der ersten Anmeldung eines noch nicht angelegten Admin-Benutzers (Einladung) geprüft werden.",
+    summary: "Anmeldemethoden und Passwort-Regeln für Kunden.",
+    icon: "ShieldCheck",
+    switchable: false,
+    features_heading: "Anmeldemethoden",
+    features_note: "Wirkt nach ca. 30 Sekunden im Backend, in der Storefront nach ca. 1 Minute.",
+    all_off_warning: "Keine Methode eingeschaltet: Kunden können sich nicht mehr anmelden.",
+    require_enabled_feature: true,
+    features: [
+        {
+            key: customer_auth_1.CUSTOMER_AUTH_FEATURES.emailPassword,
+            label: "E-Mail + Passwort",
+            description: "Anmeldung, Registrierung und Passwort-Zurücksetzen. Aus: Das Backend lehnt diese Wege für Kunden ab; bestehende Konten melden sich dann nur noch mit den anderen eingeschalteten Methoden an.",
+            default_enabled: true,
+        },
+        {
+            key: customer_auth_1.CUSTOMER_AUTH_FEATURES.emailOtp,
+            label: "Anmeldecode per E-Mail",
+            description: "Kunden fordern einen sechsstelligen Code an, der 10 Minuten gültig ist, und melden sich damit an; für neue Adressen entsteht dabei ein Kundenkonto. Ein bestehendes Passwort-Konto derselben Adresse wird nur verknüpft, wenn die Passwort-Anmeldung aus ist oder die Adresse bestätigt wurde. Die Code-Mail geht unabhängig von den Schaltern des E-Mail-Plugins hinaus. Aus: Code-Anfrage und Code-Anmeldung sind nicht möglich.",
+            default_enabled: false,
+        },
+    ],
+    setting_groups: [
+        {
+            name: PASSWORD_RULES,
+            description: "Gelten nur für Kunden mit „E-Mail + Passwort“, bei Registrierung und Passwort-Zurücksetzen. Admin-Benutzer behalten mindestens 15 Zeichen.",
+            requires_feature: customer_auth_1.CUSTOMER_AUTH_FEATURES.emailPassword,
+        },
+    ],
+    settings: [
+        {
+            key: "password_min_length",
+            label: "Mindestlänge",
+            description: "Wie viele Zeichen ein Kundenpasswort mindestens haben muss (8 bis 128). NIST SP 800-63B Rev. 4, die US-Richtlinie für digitale Identität, empfiehlt mindestens 15 Zeichen, wenn das Passwort der einzige Faktor ist. Die Regeln gelten nur, solange „E-Mail + Passwort“ eingeschaltet ist, und nur für Kunden; Admin-Benutzer behalten mindestens 15 Zeichen. Bestehende Passwörter bleiben gültig, die Regeln greifen bei Registrierung und Passwort-Zurücksetzen. Grenze: Wer sich über den Admin-Weg registriert, kann 15 Zeichen ohne Zusammensetzungsregeln wählen, auch wenn der Shop mehr verlangt; das schwächt nur das eigene Passwort.",
+            hint: "8 bis 128 Zeichen. Empfohlen: mindestens 15 (NIST SP 800-63B).",
+            group: PASSWORD_RULES,
+            width: "half",
+            type: "number",
+            min: 8,
+            max: 128,
+            integer: true,
+            default: 15,
+        },
+        {
+            key: "password_require_mixed_case",
+            label: "Groß- und Kleinbuchstaben verlangen",
+            description: "Mindestens ein Groß- und ein Kleinbuchstabe.",
+            hint: "NIST rät von Zusammensetzungsregeln ab: Sie führen zu vorhersehbaren Passwörtern wie „Passwort1!“. Länge schützt besser.",
+            group: PASSWORD_RULES,
+            type: "boolean",
+            default: false,
+        },
+        {
+            key: "password_require_digit",
+            label: "Ziffer verlangen",
+            description: "Mindestens eine Ziffer.",
+            group: PASSWORD_RULES,
+            type: "boolean",
+            default: false,
+        },
+        {
+            key: "password_require_symbol",
+            label: "Sonderzeichen verlangen",
+            description: "Mindestens ein Sonderzeichen (kein Buchstabe, keine Ziffer, kein Leerzeichen).",
+            group: PASSWORD_RULES,
+            type: "boolean",
+            default: false,
+        },
+    ],
+});

package/dist/email/customer-verification-snapshot.d.ts

@@ -4,21 +4,9 @@
  * `projectConfig.http.authVerificationsPerActor.customer` synchronously on
  * every login. The shop preset puts `customerVerificationActors()` behind a
  * getter there, so a toggle change in the Admin takes effect without a
- * restart.
- *
- * - Boot: `startCustomerVerificationSnapshot` loads the toggle once.
- * - Afterwards an unref'd timer refreshes every 30 s, so a change reaches an
- *   idle instance too. A read that finds the copy older than 30 s (a blocked
- *   timer, say) also starts one refresh in the background
- *   (stale-while-revalidate) and still answers from the copy. A change thus
- *   reaches a running instance within about 30 s plus the duration of the
- *   read.
- * - A failed read keeps the last value (initially "off") and is logged; the
- *   next attempt waits another 30 s.
- *
- * The state lives on `globalThis`: the preset (`dist`) and the Medusa-loaded
- * plugin code (`.medusa/server`) are compiled separately and would otherwise
- * each hold their own copy. Login is not on the cart path.
+ * restart. Loading, the 30 s refresh and the failure behavior (keep the last
+ * value, initially "off") are those of `createRefreshingSnapshot`. Login is
+ * not on the cart path.
  */
 export declare const CUSTOMER_VERIFICATION_REFRESH_MS = 30000;
 export type CustomerVerificationActor = Readonly<{

package/dist/email/customer-verification-snapshot.js

@@ -1,117 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setCustomerVerificationEnabledForTests = exports.customerVerificationActors = exports.isCustomerVerificationEnabled = exports.startCustomerVerificationSnapshot = exports.stopCustomerVerificationSnapshot = exports.refreshCustomerVerificationSnapshot = exports.CUSTOMER_VERIFICATION_REFRESH_MS = void 0;
+const refreshing_snapshot_1 = require("../shared/lib/refreshing-snapshot");
 /**
  * In-memory copy of the effective `customer_verification` toggle for the one
  * place that cannot await it: Medusa reads
  * `projectConfig.http.authVerificationsPerActor.customer` synchronously on
  * every login. The shop preset puts `customerVerificationActors()` behind a
  * getter there, so a toggle change in the Admin takes effect without a
- * restart.
- *
- * - Boot: `startCustomerVerificationSnapshot` loads the toggle once.
- * - Afterwards an unref'd timer refreshes every 30 s, so a change reaches an
- *   idle instance too. A read that finds the copy older than 30 s (a blocked
- *   timer, say) also starts one refresh in the background
- *   (stale-while-revalidate) and still answers from the copy. A change thus
- *   reaches a running instance within about 30 s plus the duration of the
- *   read.
- * - A failed read keeps the last value (initially "off") and is logged; the
- *   next attempt waits another 30 s.
- *
- * The state lives on `globalThis`: the preset (`dist`) and the Medusa-loaded
- * plugin code (`.medusa/server`) are compiled separately and would otherwise
- * each hold their own copy. Login is not on the cart path.
+ * restart. Loading, the 30 s refresh and the failure behavior (keep the last
+ * value, initially "off") are those of `createRefreshingSnapshot`. Login is
+ * not on the cart path.
  */
-exports.CUSTOMER_VERIFICATION_REFRESH_MS = 30_000;
-const STATE_KEY = Symbol.for("@hartl-services/medusa-base/customer-verification-snapshot");
-const state = () => {
-    const holder = globalThis;
-    holder[STATE_KEY] ??= {
-        enabled: false,
-        refreshedAt: null,
-        refreshing: null,
-        timer: null,
-        read: null,
-        warn: null,
-    };
-    return holder[STATE_KEY];
-};
-const logFailure = (current, error) => {
-    try {
-        current.warn?.(`Customer verification toggle could not be read, keeping "${current.enabled ? "on" : "off"}": ${error instanceof Error ? error.message : "unknown error"}`);
-    }
-    catch {
-        // A broken logger must not turn a failed refresh into a throw.
-    }
-};
+exports.CUSTOMER_VERIFICATION_REFRESH_MS = refreshing_snapshot_1.SNAPSHOT_REFRESH_MS;
+// The initial value is "off" (no verification) until the toggle has been read.
+const snapshot = (0, refreshing_snapshot_1.createRefreshingSnapshot)({
+    key: "@hartl-services/medusa-base/customer-verification-snapshot",
+    initial: false,
+    describe: (enabled) => `Customer verification toggle could not be read, keeping "${enabled ? "on" : "off"}"`,
+});
 /** Reads the toggle once; never rejects. Concurrent calls share one read. */
-const refreshCustomerVerificationSnapshot = () => {
-    const current = state();
-    if (!current.read) {
-        return Promise.resolve();
-    }
-    if (current.refreshing) {
-        return current.refreshing;
-    }
-    const read = current.read;
-    // Started from a microtask so the assignment below always precedes `finally`.
-    const refreshing = Promise.resolve().then(async () => {
-        try {
-            current.enabled = (await read()) === true;
-        }
-        catch (error) {
-            logFailure(current, error);
-        }
-        finally {
-            current.refreshedAt = Date.now();
-            current.refreshing = null;
-        }
-    });
-    current.refreshing = refreshing;
-    return refreshing;
-};
+const refreshCustomerVerificationSnapshot = () => snapshot.refresh();
 exports.refreshCustomerVerificationSnapshot = refreshCustomerVerificationSnapshot;
-const stopTimer = (current) => {
-    if (current.timer) {
-        clearInterval(current.timer);
-        current.timer = null;
-    }
-};
 /** Stops the periodic refresh (application shutdown). The value stays. */
-const stopCustomerVerificationSnapshot = () => {
-    stopTimer(state());
-};
+const stopCustomerVerificationSnapshot = () => snapshot.stop();
 exports.stopCustomerVerificationSnapshot = stopCustomerVerificationSnapshot;
 /**
  * Registers the reader, loads the toggle once and keeps it fresh every 30 s
  * (application start). `read` returns the effective toggle; `warn` is the
  * container logger. Starting again replaces the reader and the timer.
  */
-const startCustomerVerificationSnapshot = (input) => {
-    const current = state();
-    current.read = input.read;
-    current.warn = input.warn;
-    stopTimer(current);
-    current.timer = setInterval(() => {
-        void (0, exports.refreshCustomerVerificationSnapshot)();
-    }, exports.CUSTOMER_VERIFICATION_REFRESH_MS);
-    // An idle timer must not keep the process (or a test run) alive.
-    current.timer.unref();
-    return (0, exports.refreshCustomerVerificationSnapshot)();
-};
+const startCustomerVerificationSnapshot = (input) => snapshot.start({
+    read: async () => (await input.read()) === true,
+    warn: input.warn,
+});
 exports.startCustomerVerificationSnapshot = startCustomerVerificationSnapshot;
 /** Synchronous; starts a background refresh when the copy is stale. Never throws. */
-const isCustomerVerificationEnabled = () => {
-    const current = state();
-    if (current.read &&
-        !current.refreshing &&
-        (current.refreshedAt === null ||
-            Date.now() - current.refreshedAt >= exports.CUSTOMER_VERIFICATION_REFRESH_MS)) {
-        void (0, exports.refreshCustomerVerificationSnapshot)();
-    }
-    return current.enabled;
-};
+const isCustomerVerificationEnabled = () => snapshot.current();
 exports.isCustomerVerificationEnabled = isCustomerVerificationEnabled;
 /**
  * The value of `authVerificationsPerActor.customer`: Medusa's e-mail
@@ -126,18 +51,5 @@ exports.customerVerificationActors = customerVerificationActors;
  * Test hook: sets the value and counts as just refreshed, so it holds for
  * 30 s without a reader; `null` forgets reader and value.
  */
-const setCustomerVerificationEnabledForTests = (enabled) => {
-    const current = state();
-    if (enabled === null) {
-        stopTimer(current);
-        current.enabled = false;
-        current.refreshedAt = null;
-        current.refreshing = null;
-        current.read = null;
-        current.warn = null;
-        return;
-    }
-    current.enabled = enabled;
-    current.refreshedAt = Date.now();
-};
+const setCustomerVerificationEnabledForTests = (enabled) => snapshot.setForTests(enabled);
 exports.setCustomerVerificationEnabledForTests = setCustomerVerificationEnabledForTests;

package/dist/email/types/email-kinds.d.ts

@@ -1,5 +1,5 @@
 import { z } from "@medusajs/framework/zod";
-export declare const EMAIL_KINDS: readonly ["order.received", "order.received.admin", "order.shipped", "order.canceled", "order.return_requested", "order.return_received", "order.refunded", "auth.password_reset", "affiliate.consignment_report_due", "affiliate.application_submitted.admin", "user.invite", "auth.verification"];
+export declare const EMAIL_KINDS: readonly ["order.received", "order.received.admin", "order.shipped", "order.canceled", "order.return_requested", "order.return_received", "order.refunded", "auth.password_reset", "affiliate.consignment_report_due", "affiliate.application_submitted.admin", "user.invite", "auth.verification", "auth.login_code"];
 export declare const EmailKindSchema: z.ZodEnum<{
     "order.received": "order.received";
     "order.received.admin": "order.received.admin";
@@ -13,12 +13,13 @@ export declare const EmailKindSchema: z.ZodEnum<{
     "affiliate.application_submitted.admin": "affiliate.application_submitted.admin";
     "user.invite": "user.invite";
     "auth.verification": "auth.verification";
+    "auth.login_code": "auth.login_code";
 }>;
 export type EmailKind = (typeof EMAIL_KINDS)[number];
 /**
- * Kinds whose link carries a one-time token that is never persisted: the
+ * Kinds whose link or code carries a one-time secret that is never persisted: the
  * subscriber builds the mail from the event, so neither the generic retry
  * job, the automatic dispatch nor an Admin resend may touch them.
  */
-export declare const EPHEMERAL_EMAIL_KINDS: readonly ["auth.password_reset", "auth.verification"];
+export declare const EPHEMERAL_EMAIL_KINDS: readonly ["auth.password_reset", "auth.verification", "auth.login_code"];
 export declare const isEphemeralEmailKind: (kind: EmailKind) => boolean;

package/dist/email/types/email-kinds.js

@@ -15,16 +15,18 @@ exports.EMAIL_KINDS = [
     "affiliate.application_submitted.admin",
     "user.invite",
     "auth.verification",
+    "auth.login_code",
 ];
 exports.EmailKindSchema = zod_1.z.enum(exports.EMAIL_KINDS);
 /**
- * Kinds whose link carries a one-time token that is never persisted: the
+ * Kinds whose link or code carries a one-time secret that is never persisted: the
  * subscriber builds the mail from the event, so neither the generic retry
  * job, the automatic dispatch nor an Admin resend may touch them.
  */
 exports.EPHEMERAL_EMAIL_KINDS = [
     "auth.password_reset",
     "auth.verification",
+    "auth.login_code",
 ];
 const isEphemeralEmailKind = (kind) => exports.EPHEMERAL_EMAIL_KINDS.includes(kind);
 exports.isEphemeralEmailKind = isEphemeralEmailKind;

package/dist/email/types/template-data.d.ts

@@ -375,6 +375,7 @@ export declare const EmailPersistedDataSchemas: {
     readonly "auth.verification": z.ZodObject<{
         locale: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>;
+    readonly "auth.login_code": z.ZodObject<{}, z.core.$strict>;
 };
 export declare const EmailRenderDataSchemas: {
     readonly "auth.password_reset": z.ZodObject<{
@@ -390,6 +391,10 @@ export declare const EmailRenderDataSchemas: {
         locale: z.ZodNullable<z.ZodString>;
         verify_url: z.ZodString;
     }, z.core.$strict>;
+    readonly "auth.login_code": z.ZodObject<{
+        code: z.ZodString;
+        valid_minutes: z.ZodNumber;
+    }, z.core.$strict>;
     readonly "order.received": z.ZodObject<{
         order_id: z.ZodString;
         summary: z.ZodOptional<z.ZodObject<{
@@ -628,6 +633,9 @@ export type EmailEphemeralRenderContextMap = {
         expires_at?: string;
     }> : Kind extends "auth.verification" ? Readonly<{
         verify_url: string;
+    }> : Kind extends "auth.login_code" ? Readonly<{
+        code: string;
+        valid_minutes: number;
     }> : EmptyRenderContext;
 };
 export type EmailRenderDataMap = {

package/dist/email/types/template-data.js

@@ -231,6 +231,8 @@ exports.EmailPersistedDataSchemas = {
         locale: NullableLocaleSchema,
     })
         .strict(),
+    // The code itself is never stored: it only exists in the render context.
+    "auth.login_code": zod_1.z.object({}).strict(),
 };
 exports.EmailRenderDataSchemas = {
     ...exports.EmailPersistedDataSchemas,
@@ -247,4 +249,10 @@ exports.EmailRenderDataSchemas = {
     "auth.verification": exports.EmailPersistedDataSchemas["auth.verification"].extend({
         verify_url: zod_1.z.string().url(),
     }),
+    "auth.login_code": exports.EmailPersistedDataSchemas["auth.login_code"].extend({
+        /** The six digits; never persisted, only passed to rendering. */
+        code: zod_1.z.string().regex(/^[0-9]{6}$/),
+        /** How long the code is valid, in minutes. */
+        valid_minutes: zod_1.z.number().int().positive(),
+    }),
 };