@voyantjs/storefront-verification 0.24.1 → 0.24.3

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { HonoModule } from "@voyantjs/hono/module";
+import { type StorefrontVerificationRoutesOptions } from "./routes-public.js";
+export type { StorefrontVerificationPublicRoutes, StorefrontVerificationRoutesOptions, } from "./routes-public.js";
+export { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+export type { NewStorefrontVerificationChallenge, StorefrontVerificationChallenge, } from "./schema.js";
+export { storefrontVerificationChallenges, storefrontVerificationChannelEnum, storefrontVerificationLinkable, storefrontVerificationModule, storefrontVerificationStatusEnum, } from "./schema.js";
+export type { StorefrontVerificationDeliveryResult, StorefrontVerificationEmailSendInput, StorefrontVerificationProviderOptions, StorefrontVerificationSenders, StorefrontVerificationServiceOptions, StorefrontVerificationSmsSendInput, } from "./service.js";
+export { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+export type { ConfirmEmailVerificationChallengeInput, ConfirmSmsVerificationChallengeInput, StartEmailVerificationChallengeInput, StartSmsVerificationChallengeInput, StorefrontVerificationChallengeRecord, StorefrontVerificationChannel, StorefrontVerificationConfirmResult, StorefrontVerificationStartResult, StorefrontVerificationStatus, } from "./validation.js";
+export { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, storefrontVerificationChallengeRecordSchema, storefrontVerificationChannelSchema, storefrontVerificationConfirmResultSchema, storefrontVerificationStartResultSchema, storefrontVerificationStatusSchema, } from "./validation.js";
+export declare function createStorefrontVerificationHonoModule(options?: StorefrontVerificationRoutesOptions): HonoModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAIL,KAAK,mCAAmC,EACzC,MAAM,oBAAoB,CAAA;AAG3B,YAAY,EACV,kCAAkC,EAClC,mCAAmC,GACpC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,kCAAkC,EAClC,wCAAwC,EACxC,6CAA6C,GAC9C,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EACV,kCAAkC,EAClC,+BAA+B,GAChC,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,gCAAgC,EAChC,iCAAiC,EACjC,8BAA8B,EAC9B,4BAA4B,EAC5B,gCAAgC,GACjC,MAAM,aAAa,CAAA;AACpB,YAAY,EACV,oCAAoC,EACpC,oCAAoC,EACpC,qCAAqC,EACrC,6BAA6B,EAC7B,oCAAoC,EACpC,kCAAkC,GACnC,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,gDAAgD,EAChD,mCAAmC,EACnC,2BAA2B,GAC5B,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,sCAAsC,EACtC,oCAAoC,EACpC,oCAAoC,EACpC,kCAAkC,EAClC,qCAAqC,EACrC,6BAA6B,EAC7B,mCAAmC,EACnC,iCAAiC,EACjC,4BAA4B,GAC7B,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,uCAAuC,EACvC,qCAAqC,EACrC,qCAAqC,EACrC,mCAAmC,EACnC,2CAA2C,EAC3C,mCAAmC,EACnC,yCAAyC,EACzC,uCAAuC,EACvC,kCAAkC,GACnC,MAAM,iBAAiB,CAAA;AAExB,wBAAgB,sCAAsC,CACpD,OAAO,CAAC,EAAE,mCAAmC,GAC5C,UAAU,CAeZ"}

package/dist/index.js

@@ -0,0 +1,18 @@
+import { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+import { storefrontVerificationModule } from "./schema.js";
+export { buildStorefrontVerificationSenders, createStorefrontVerificationPublicRoutes, STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, } from "./routes-public.js";
+export { storefrontVerificationChallenges, storefrontVerificationChannelEnum, storefrontVerificationLinkable, storefrontVerificationModule, storefrontVerificationStatusEnum, } from "./schema.js";
+export { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+export { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, storefrontVerificationChallengeRecordSchema, storefrontVerificationChannelSchema, storefrontVerificationConfirmResultSchema, storefrontVerificationStartResultSchema, storefrontVerificationStatusSchema, } from "./validation.js";
+export function createStorefrontVerificationHonoModule(options) {
+    const module = {
+        ...storefrontVerificationModule,
+        bootstrap: ({ bindings, container }) => {
+            container.register(STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY, buildStorefrontVerificationSenders(bindings, options));
+        },
+    };
+    return {
+        module,
+        publicRoutes: createStorefrontVerificationPublicRoutes(options),
+    };
+}

package/dist/routes-public.d.ts

@@ -0,0 +1,184 @@
+import type { ModuleContainer } from "@voyantjs/core";
+import type { NotificationProvider } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type StorefrontVerificationProviderOptions, type StorefrontVerificationSenders, type StorefrontVerificationServiceOptions } from "./service.js";
+type Env = {
+    Bindings: Record<string, unknown>;
+    Variables: {
+        container: ModuleContainer;
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export interface StorefrontVerificationRoutesOptions extends StorefrontVerificationServiceOptions, StorefrontVerificationProviderOptions {
+    sendEmailChallenge?: StorefrontVerificationSenders["sendEmailChallenge"];
+    sendSmsChallenge?: StorefrontVerificationSenders["sendSmsChallenge"];
+    providers?: ReadonlyArray<NotificationProvider>;
+    resolveProviders?: (bindings: Record<string, unknown>) => ReadonlyArray<NotificationProvider>;
+}
+export declare const STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY = "providers.storefrontVerification.senders";
+export declare function buildStorefrontVerificationSenders(bindings: Record<string, unknown>, options?: StorefrontVerificationRoutesOptions): StorefrontVerificationSenders;
+export declare function createStorefrontVerificationPublicRoutes(options?: StorefrontVerificationRoutesOptions): import("hono/hono-base").HonoBase<Env, {
+    "/email/start": {
+        $post: {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        } | {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404 | 409 | 410 | 501;
+        };
+    };
+} & {
+    "/email/confirm": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404 | 409 | 410 | 501;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+} & {
+    "/sms/start": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404 | 409 | 410 | 501;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: 201;
+        };
+    };
+} & {
+    "/sms/confirm": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                code: "sender_not_configured";
+            } | {
+                error: string;
+                code: "challenge_not_found";
+            } | {
+                error: string;
+                code: "challenge_expired";
+            } | {
+                error: string;
+                code: "challenge_invalid" | "challenge_failed";
+            } | {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400 | 404 | 409 | 410 | 501;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    channel: "email" | "sms";
+                    destination: string;
+                    purpose: string;
+                    status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+                    expiresAt: string;
+                    verifiedAt: string | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/", "/sms/confirm">;
+export type StorefrontVerificationPublicRoutes = ReturnType<typeof createStorefrontVerificationPublicRoutes>;
+export {};
+//# sourceMappingURL=routes-public.d.ts.map

package/dist/routes-public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-public.d.ts","sourceRoot":"","sources":["../src/routes-public.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAIL,KAAK,qCAAqC,EAC1C,KAAK,6BAA6B,EAClC,KAAK,oCAAoC,EAC1C,MAAM,cAAc,CAAA;AAQrB,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,SAAS,EAAE,eAAe,CAAA;QAC1B,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,MAAM,WAAW,mCACf,SAAQ,oCAAoC,EAC1C,qCAAqC;IACvC,kBAAkB,CAAC,EAAE,6BAA6B,CAAC,oBAAoB,CAAC,CAAA;IACxE,gBAAgB,CAAC,EAAE,6BAA6B,CAAC,kBAAkB,CAAC,CAAA;IACpE,SAAS,CAAC,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;IAC/C,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,aAAa,CAAC,oBAAoB,CAAC,CAAA;CAC9F;AAED,eAAO,MAAM,6CAA6C,6CACd,CAAA;AAE5C,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,mCAAmC,GAC5C,6BAA6B,CAgB/B;AA2CD,wBAAgB,wCAAwC,CACtD,OAAO,CAAC,EAAE,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAuD9C;AAED,MAAM,MAAM,kCAAkC,GAAG,UAAU,CACzD,OAAO,wCAAwC,CAChD,CAAA"}

package/dist/routes-public.js

@@ -0,0 +1,93 @@
+import { parseJsonBody } from "@voyantjs/hono";
+import { Hono } from "hono";
+import { createStorefrontVerificationSendersFromProviders, createStorefrontVerificationService, StorefrontVerificationError, } from "./service.js";
+import { confirmEmailVerificationChallengeSchema, confirmSmsVerificationChallengeSchema, startEmailVerificationChallengeSchema, startSmsVerificationChallengeSchema, } from "./validation.js";
+export const STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY = "providers.storefrontVerification.senders";
+export function buildStorefrontVerificationSenders(bindings, options) {
+    const senders = {
+        sendEmailChallenge: options?.sendEmailChallenge,
+        sendSmsChallenge: options?.sendSmsChallenge,
+    };
+    if (!senders.sendEmailChallenge || !senders.sendSmsChallenge) {
+        const providers = options?.resolveProviders?.(bindings) ?? options?.providers;
+        if (providers?.length) {
+            const providerSenders = createStorefrontVerificationSendersFromProviders(providers, options);
+            senders.sendEmailChallenge ??= providerSenders.sendEmailChallenge;
+            senders.sendSmsChallenge ??= providerSenders.sendSmsChallenge;
+        }
+    }
+    return senders;
+}
+function getSenders(bindings, options, resolveFromContainer) {
+    if (resolveFromContainer) {
+        try {
+            return resolveFromContainer(STOREFRONT_VERIFICATION_SENDERS_CONTAINER_KEY);
+        }
+        catch {
+            // Fall back to per-request sender construction when bootstrap has not run.
+        }
+    }
+    return buildStorefrontVerificationSenders(bindings, options);
+}
+function errorResponse(error) {
+    if (error instanceof StorefrontVerificationError) {
+        if (error.code === "sender_not_configured") {
+            return { status: 501, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_not_found") {
+            return { status: 404, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_expired") {
+            return { status: 410, body: { error: error.message, code: error.code } };
+        }
+        if (error.code === "challenge_invalid" || error.code === "challenge_failed") {
+            return { status: 409, body: { error: error.message, code: error.code } };
+        }
+    }
+    const message = error instanceof Error ? error.message : "Verification request failed";
+    return { status: 400, body: { error: message } };
+}
+export function createStorefrontVerificationPublicRoutes(options) {
+    const service = createStorefrontVerificationService(options);
+    return new Hono()
+        .post("/email/start", async (c) => {
+        try {
+            const result = await service.startEmailChallenge(c.get("db"), await parseJsonBody(c, startEmailVerificationChallengeSchema), getSenders(c.env, options, (key) => c.var.container.resolve(key)));
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/email/confirm", async (c) => {
+        try {
+            const result = await service.confirmEmailChallenge(c.get("db"), await parseJsonBody(c, confirmEmailVerificationChallengeSchema));
+            return c.json({ data: result });
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/sms/start", async (c) => {
+        try {
+            const result = await service.startSmsChallenge(c.get("db"), await parseJsonBody(c, startSmsVerificationChallengeSchema), getSenders(c.env, options, (key) => c.var.container.resolve(key)));
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    })
+        .post("/sms/confirm", async (c) => {
+        try {
+            const result = await service.confirmSmsChallenge(c.get("db"), await parseJsonBody(c, confirmSmsVerificationChallengeSchema));
+            return c.json({ data: result });
+        }
+        catch (error) {
+            const response = errorResponse(error);
+            return c.json(response.body, response.status);
+        }
+    });
+}

package/dist/schema.d.ts

@@ -0,0 +1,273 @@
+import type { LinkableDefinition, Module } from "@voyantjs/core";
+export declare const storefrontVerificationChannelEnum: import("drizzle-orm/pg-core").PgEnum<["email", "sms"]>;
+export declare const storefrontVerificationStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "verified", "expired", "failed", "cancelled"]>;
+export declare const storefrontVerificationChallenges: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "storefront_verification_challenges";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        channel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "channel";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "email" | "sms";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["email", "sms"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        destination: import("drizzle-orm/pg-core").PgColumn<{
+            name: "destination";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        purpose: import("drizzle-orm/pg-core").PgColumn<{
+            name: "purpose";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        codeHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code_hash";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "storefront_verification_challenges";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "verified" | "failed" | "expired" | "cancelled";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "verified", "expired", "failed", "cancelled"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attemptCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempt_count";
+            tableName: "storefront_verification_challenges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_attempts";
+            tableName: "storefront_verification_challenges";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastSentAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_sent_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        verifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "verified_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        failedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "failed_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "storefront_verification_challenges";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "storefront_verification_challenges";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const storefrontVerificationChallengesRelations: import("drizzle-orm").Relations<"storefront_verification_challenges", {}>;
+export type StorefrontVerificationChallenge = typeof storefrontVerificationChallenges.$inferSelect;
+export type NewStorefrontVerificationChallenge = typeof storefrontVerificationChallenges.$inferInsert;
+export declare const storefrontVerificationLinkable: LinkableDefinition;
+export declare const storefrontVerificationModule: Module;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAKhE,eAAO,MAAM,iCAAiC,wDAG5C,CAAA;AAEF,eAAO,MAAM,gCAAgC,iGAM3C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC5C,CAAA;AAED,eAAO,MAAM,yCAAyC,2EAGrD,CAAA;AAED,MAAM,MAAM,+BAA+B,GAAG,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAClG,MAAM,MAAM,kCAAkC,GAC5C,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAEtD,eAAO,MAAM,8BAA8B,EAAE,kBAK5C,CAAA;AAED,eAAO,MAAM,4BAA4B,EAAE,MAK1C,CAAA"}

package/dist/schema.js

@@ -0,0 +1,50 @@
+import { typeId } from "@voyantjs/db/lib/typeid-column";
+import { relations } from "drizzle-orm";
+import { index, integer, jsonb, pgEnum, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+export const storefrontVerificationChannelEnum = pgEnum("storefront_verification_channel", [
+    "email",
+    "sms",
+]);
+export const storefrontVerificationStatusEnum = pgEnum("storefront_verification_status", [
+    "pending",
+    "verified",
+    "expired",
+    "failed",
+    "cancelled",
+]);
+export const storefrontVerificationChallenges = pgTable("storefront_verification_challenges", {
+    id: typeId("storefront_verification_challenges"),
+    channel: storefrontVerificationChannelEnum("channel").notNull(),
+    destination: text("destination").notNull(),
+    purpose: text("purpose").notNull().default("contact_confirmation"),
+    codeHash: text("code_hash").notNull(),
+    status: storefrontVerificationStatusEnum("status").notNull().default("pending"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull().default(5),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    lastSentAt: timestamp("last_sent_at", { withTimezone: true }).notNull().defaultNow(),
+    verifiedAt: timestamp("verified_at", { withTimezone: true }),
+    failedAt: timestamp("failed_at", { withTimezone: true }),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_storefront_verification_channel").on(table.channel),
+    index("idx_storefront_verification_destination").on(table.destination),
+    index("idx_storefront_verification_purpose").on(table.purpose),
+    index("idx_storefront_verification_status").on(table.status),
+    index("idx_storefront_verification_lookup").on(table.channel, table.destination, table.purpose, table.updatedAt, table.createdAt),
+]);
+export const storefrontVerificationChallengesRelations = relations(storefrontVerificationChallenges, () => ({}));
+export const storefrontVerificationLinkable = {
+    module: "storefront-verification",
+    entity: "storefrontVerificationChallenge",
+    table: "storefront_verification_challenges",
+    idPrefix: "svch",
+};
+export const storefrontVerificationModule = {
+    name: "storefront-verification",
+    linkable: {
+        storefrontVerificationChallenge: storefrontVerificationLinkable,
+    },
+};

package/dist/service.d.ts

@@ -0,0 +1,96 @@
+import type { NotificationProvider } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ConfirmEmailVerificationChallengeInput, ConfirmSmsVerificationChallengeInput, StartEmailVerificationChallengeInput, StartSmsVerificationChallengeInput } from "./validation.js";
+export interface StorefrontVerificationServiceOptions {
+    codeLength?: number;
+    expiresInSeconds?: number;
+    maxAttempts?: number;
+    now?: () => Date;
+}
+export interface StorefrontVerificationDeliveryResult {
+    id?: string;
+    provider?: string;
+}
+export interface StorefrontVerificationEmailSendInput {
+    email: string;
+    code: string;
+    purpose: string;
+    locale?: string | null;
+    expiresAt: Date;
+    metadata?: Record<string, unknown> | null;
+}
+export interface StorefrontVerificationSmsSendInput {
+    phone: string;
+    code: string;
+    purpose: string;
+    locale?: string | null;
+    expiresAt: Date;
+    metadata?: Record<string, unknown> | null;
+}
+export interface StorefrontVerificationSenders {
+    sendEmailChallenge?: (input: StorefrontVerificationEmailSendInput) => Promise<StorefrontVerificationDeliveryResult | undefined>;
+    sendSmsChallenge?: (input: StorefrontVerificationSmsSendInput) => Promise<StorefrontVerificationDeliveryResult | undefined>;
+}
+export interface StorefrontVerificationProviderOptions {
+    email?: {
+        provider?: string;
+        template?: string;
+        subject?: string | ((input: StorefrontVerificationEmailSendInput) => string);
+    };
+    sms?: {
+        provider?: string;
+        template?: string;
+    };
+}
+export declare class StorefrontVerificationError extends Error {
+    readonly code: "sender_not_configured" | "challenge_not_found" | "challenge_expired" | "challenge_invalid" | "challenge_failed";
+    constructor(message: string, code: "sender_not_configured" | "challenge_not_found" | "challenge_expired" | "challenge_invalid" | "challenge_failed");
+}
+export declare function createStorefrontVerificationSendersFromProviders(providers: ReadonlyArray<NotificationProvider>, options?: StorefrontVerificationProviderOptions): StorefrontVerificationSenders;
+export declare function createStorefrontVerificationService(options?: StorefrontVerificationServiceOptions): {
+    startEmailChallenge(db: PostgresJsDatabase, input: StartEmailVerificationChallengeInput, senders: StorefrontVerificationSenders): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    startSmsChallenge(db: PostgresJsDatabase, input: StartSmsVerificationChallengeInput, senders: StorefrontVerificationSenders): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    confirmEmailChallenge(db: PostgresJsDatabase, input: ConfirmEmailVerificationChallengeInput): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    confirmSmsChallenge(db: PostgresJsDatabase, input: ConfirmSmsVerificationChallengeInput): Promise<{
+        id: string;
+        channel: "email" | "sms";
+        destination: string;
+        purpose: string;
+        status: "pending" | "verified" | "failed" | "expired" | "cancelled";
+        expiresAt: Date;
+        verifiedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAGnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,sCAAsC,EACtC,oCAAoC,EACpC,oCAAoC,EACpC,kCAAkC,EAGnC,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,oCAAoC;IACnD,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAA;CACjB;AAED,MAAM,WAAW,oCAAoC;IACnD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,oCAAoC;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,IAAI,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,WAAW,kCAAkC;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,SAAS,EAAE,IAAI,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,WAAW,6BAA6B;IAC5C,kBAAkB,CAAC,EAAE,CACnB,KAAK,EAAE,oCAAoC,KACxC,OAAO,CAAC,oCAAoC,GAAG,SAAS,CAAC,CAAA;IAC9D,gBAAgB,CAAC,EAAE,CACjB,KAAK,EAAE,kCAAkC,KACtC,OAAO,CAAC,oCAAoC,GAAG,SAAS,CAAC,CAAA;CAC/D;AAED,MAAM,WAAW,qCAAqC;IACpD,KAAK,CAAC,EAAE;QACN,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,oCAAoC,KAAK,MAAM,CAAC,CAAA;KAC7E,CAAA;IACD,GAAG,CAAC,EAAE;QACJ,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;KAClB,CAAA;CACF;AAED,qBAAa,2BAA4B,SAAQ,KAAK;IAGlD,QAAQ,CAAC,IAAI,EACT,uBAAuB,GACvB,qBAAqB,GACrB,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB;gBANtB,OAAO,EAAE,MAAM,EACN,IAAI,EACT,uBAAuB,GACvB,qBAAqB,GACrB,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB;CAKzB;AA6MD,wBAAgB,gDAAgD,CAC9D,SAAS,EAAE,aAAa,CAAC,oBAAoB,CAAC,EAC9C,OAAO,GAAE,qCAA0C,GAClD,6BAA6B,CA8C/B;AAED,wBAAgB,mCAAmC,CACjD,OAAO,CAAC,EAAE,oCAAoC;4BAItC,kBAAkB,SACf,oCAAoC,WAClC,6BAA6B;;;;;;;;;;;0BA6ClC,kBAAkB,SACf,kCAAkC,WAChC,6BAA6B;;;;;;;;;;;8BA6ClC,kBAAkB,SACf,sCAAsC;;;;;;;;;;;4BAajB,kBAAkB,SAAS,oCAAoC;;;;;;;;;;;EAYhG"}

package/dist/service.js

@@ -0,0 +1,268 @@
+import { createNotificationService } from "@voyantjs/notifications";
+import { and, desc, eq } from "drizzle-orm";
+import { storefrontVerificationChallenges } from "./schema.js";
+export class StorefrontVerificationError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "StorefrontVerificationError";
+    }
+}
+function normalizeEmail(value) {
+    return value.trim().toLowerCase();
+}
+function normalizePhone(value) {
+    return value.trim();
+}
+function generateVerificationCode(length) {
+    const chars = "0123456789";
+    const bytes = new Uint8Array(length);
+    crypto.getRandomValues(bytes);
+    return Array.from(bytes, (byte) => chars[byte % chars.length]).join("");
+}
+async function hashVerificationCode(code) {
+    const bytes = new TextEncoder().encode(code);
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function toChallengeRecord(row) {
+    return {
+        id: row.id,
+        channel: row.channel,
+        destination: row.destination,
+        purpose: row.purpose,
+        status: row.status,
+        expiresAt: row.expiresAt,
+        verifiedAt: row.verifiedAt ?? null,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function requireChallengeRow(row, operation) {
+    if (!row) {
+        throw new Error(`Storefront verification ${operation} did not return a challenge row`);
+    }
+    return row;
+}
+async function getLatestChallenge(db, channel, destination, purpose) {
+    const [row] = await db
+        .select()
+        .from(storefrontVerificationChallenges)
+        .where(and(eq(storefrontVerificationChallenges.channel, channel), eq(storefrontVerificationChallenges.destination, destination), eq(storefrontVerificationChallenges.purpose, purpose)))
+        .orderBy(desc(storefrontVerificationChallenges.updatedAt), desc(storefrontVerificationChallenges.createdAt))
+        .limit(1);
+    return row ?? null;
+}
+async function startChallenge(db, channel, destination, purpose, metadata, options) {
+    const now = options?.now?.() ?? new Date();
+    const codeLength = Math.max(4, Math.min(8, options?.codeLength ?? 6));
+    const maxAttempts = Math.max(1, options?.maxAttempts ?? 5);
+    const expiresInSeconds = Math.max(60, options?.expiresInSeconds ?? 600);
+    const expiresAt = new Date(now.getTime() + expiresInSeconds * 1000);
+    const code = generateVerificationCode(codeLength);
+    const codeHash = await hashVerificationCode(code);
+    const existing = await getLatestChallenge(db, channel, destination, purpose);
+    if (existing && existing.status === "pending" && existing.expiresAt > now) {
+        const [updated] = await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            codeHash,
+            attemptCount: 0,
+            maxAttempts,
+            expiresAt,
+            lastSentAt: now,
+            failedAt: null,
+            verifiedAt: null,
+            metadata: metadata ?? null,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, existing.id))
+            .returning();
+        return { challenge: requireChallengeRow(updated, "update"), code };
+    }
+    if (existing && existing.status === "pending" && existing.expiresAt <= now) {
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            status: "expired",
+            failedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, existing.id));
+    }
+    const [created] = await db
+        .insert(storefrontVerificationChallenges)
+        .values({
+        channel,
+        destination,
+        purpose,
+        codeHash,
+        status: "pending",
+        attemptCount: 0,
+        maxAttempts,
+        expiresAt,
+        lastSentAt: now,
+        metadata: metadata ?? null,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .returning();
+    return { challenge: requireChallengeRow(created, "insert"), code };
+}
+async function confirmChallenge(db, channel, destination, purpose, code, options) {
+    const now = options?.now?.() ?? new Date();
+    const row = await getLatestChallenge(db, channel, destination, purpose);
+    if (!row || row.status !== "pending") {
+        throw new StorefrontVerificationError("Verification challenge not found", "challenge_not_found");
+    }
+    if (row.expiresAt <= now) {
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            status: "expired",
+            failedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, row.id));
+        throw new StorefrontVerificationError("Verification challenge expired", "challenge_expired");
+    }
+    if (row.codeHash !== (await hashVerificationCode(code))) {
+        const nextAttemptCount = row.attemptCount + 1;
+        const terminal = nextAttemptCount >= row.maxAttempts;
+        await db
+            .update(storefrontVerificationChallenges)
+            .set({
+            attemptCount: nextAttemptCount,
+            status: terminal ? "failed" : row.status,
+            failedAt: terminal ? now : row.failedAt,
+            updatedAt: now,
+        })
+            .where(eq(storefrontVerificationChallenges.id, row.id));
+        throw new StorefrontVerificationError(terminal ? "Verification challenge failed" : "Invalid verification code", terminal ? "challenge_failed" : "challenge_invalid");
+    }
+    const [verified] = await db
+        .update(storefrontVerificationChallenges)
+        .set({
+        status: "verified",
+        verifiedAt: now,
+        updatedAt: now,
+    })
+        .where(eq(storefrontVerificationChallenges.id, row.id))
+        .returning();
+    return requireChallengeRow(verified, "confirm");
+}
+export function createStorefrontVerificationSendersFromProviders(providers, options = {}) {
+    const dispatcher = createNotificationService([...providers]);
+    return {
+        async sendEmailChallenge(input) {
+            const subject = typeof options.email?.subject === "function"
+                ? options.email.subject(input)
+                : options.email?.subject;
+            const result = await dispatcher.send({
+                to: input.email,
+                channel: "email",
+                provider: options.email?.provider,
+                template: options.email?.template ?? "storefront-verification-email",
+                subject,
+                data: {
+                    code: input.code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: input.expiresAt.toISOString(),
+                    metadata: input.metadata ?? null,
+                },
+            });
+            return { id: result.id, provider: result.provider };
+        },
+        async sendSmsChallenge(input) {
+            const result = await dispatcher.send({
+                to: input.phone,
+                channel: "sms",
+                provider: options.sms?.provider,
+                template: options.sms?.template ?? "storefront-verification-sms",
+                data: {
+                    code: input.code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: input.expiresAt.toISOString(),
+                    metadata: input.metadata ?? null,
+                },
+                text: `${input.code} is your verification code.`,
+            });
+            return { id: result.id, provider: result.provider };
+        },
+    };
+}
+export function createStorefrontVerificationService(options) {
+    return {
+        async startEmailChallenge(db, input, senders) {
+            const email = normalizeEmail(input.email);
+            const { challenge, code } = await startChallenge(db, "email", email, input.purpose, input.metadata, options);
+            if (!senders.sendEmailChallenge) {
+                throw new StorefrontVerificationError("Email verification sender not configured", "sender_not_configured");
+            }
+            try {
+                await senders.sendEmailChallenge({
+                    email,
+                    code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: challenge.expiresAt,
+                    metadata: input.metadata,
+                });
+            }
+            catch (error) {
+                const now = options?.now?.() ?? new Date();
+                await db
+                    .update(storefrontVerificationChallenges)
+                    .set({
+                    status: "failed",
+                    failedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(storefrontVerificationChallenges.id, challenge.id));
+                throw error;
+            }
+            return toChallengeRecord(challenge);
+        },
+        async startSmsChallenge(db, input, senders) {
+            const phone = normalizePhone(input.phone);
+            const { challenge, code } = await startChallenge(db, "sms", phone, input.purpose, input.metadata, options);
+            if (!senders.sendSmsChallenge) {
+                throw new StorefrontVerificationError("SMS verification sender not configured", "sender_not_configured");
+            }
+            try {
+                await senders.sendSmsChallenge({
+                    phone,
+                    code,
+                    purpose: input.purpose,
+                    locale: input.locale ?? null,
+                    expiresAt: challenge.expiresAt,
+                    metadata: input.metadata,
+                });
+            }
+            catch (error) {
+                const now = options?.now?.() ?? new Date();
+                await db
+                    .update(storefrontVerificationChallenges)
+                    .set({
+                    status: "failed",
+                    failedAt: now,
+                    updatedAt: now,
+                })
+                    .where(eq(storefrontVerificationChallenges.id, challenge.id));
+                throw error;
+            }
+            return toChallengeRecord(challenge);
+        },
+        async confirmEmailChallenge(db, input) {
+            const verified = await confirmChallenge(db, "email", normalizeEmail(input.email), input.purpose, input.code, options);
+            return toChallengeRecord(verified);
+        },
+        async confirmSmsChallenge(db, input) {
+            const verified = await confirmChallenge(db, "sms", normalizePhone(input.phone), input.purpose, input.code, options);
+            return toChallengeRecord(verified);
+        },
+    };
+}

package/dist/validation.d.ts

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const storefrontVerificationChannelSchema: z.ZodEnum<{
+    email: "email";
+    sms: "sms";
+}>;
+export declare const storefrontVerificationStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    verified: "verified";
+    failed: "failed";
+    expired: "expired";
+    cancelled: "cancelled";
+}>;
+export declare const startEmailVerificationChallengeSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    purpose: z.ZodDefault<z.ZodString>;
+    locale: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const startSmsVerificationChallengeSchema: z.ZodObject<{
+    phone: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+    locale: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    metadata: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const confirmEmailVerificationChallengeSchema: z.ZodObject<{
+    email: z.ZodEmail;
+    code: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const confirmSmsVerificationChallengeSchema: z.ZodObject<{
+    phone: z.ZodString;
+    code: z.ZodString;
+    purpose: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const storefrontVerificationChallengeRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        verified: "verified";
+        failed: "failed";
+        expired: "expired";
+        cancelled: "cancelled";
+    }>;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const storefrontVerificationStartResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        verified: "verified";
+        failed: "failed";
+        expired: "expired";
+        cancelled: "cancelled";
+    }>;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export declare const storefrontVerificationConfirmResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodEnum<{
+        email: "email";
+        sms: "sms";
+    }>;
+    destination: z.ZodString;
+    purpose: z.ZodString;
+    expiresAt: z.ZodDate;
+    verifiedAt: z.ZodNullable<z.ZodDate>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    status: z.ZodLiteral<"verified">;
+}, z.core.$strip>;
+export type StorefrontVerificationChannel = z.infer<typeof storefrontVerificationChannelSchema>;
+export type StorefrontVerificationStatus = z.infer<typeof storefrontVerificationStatusSchema>;
+export type StartEmailVerificationChallengeInput = z.infer<typeof startEmailVerificationChallengeSchema>;
+export type StartSmsVerificationChallengeInput = z.infer<typeof startSmsVerificationChallengeSchema>;
+export type ConfirmEmailVerificationChallengeInput = z.infer<typeof confirmEmailVerificationChallengeSchema>;
+export type ConfirmSmsVerificationChallengeInput = z.infer<typeof confirmSmsVerificationChallengeSchema>;
+export type StorefrontVerificationChallengeRecord = z.infer<typeof storefrontVerificationChallengeRecordSchema>;
+export type StorefrontVerificationStartResult = z.infer<typeof storefrontVerificationStartResultSchema>;
+export type StorefrontVerificationConfirmResult = z.infer<typeof storefrontVerificationConfirmResultSchema>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,mCAAmC;;;EAA2B,CAAA;AAC3E,eAAO,MAAM,kCAAkC;;;;;;EAM7C,CAAA;AAKF,eAAO,MAAM,qCAAqC;;;;;iBAKhD,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;iBAK9C,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;iBAOlD,CAAA;AAEF,eAAO,MAAM,qCAAqC;;;;iBAOhD,CAAA;AAEF,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;iBAUtD,CAAA;AAEF,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;iBAA8C,CAAA;AAElG,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;iBAGlD,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,qCAAqC,CAC7C,CAAA;AACD,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,sCAAsC,GAAG,CAAC,CAAC,KAAK,CAC1D,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,qCAAqC,CAC7C,CAAA;AACD,MAAM,MAAM,qCAAqC,GAAG,CAAC,CAAC,KAAK,CACzD,OAAO,2CAA2C,CACnD,CAAA;AACD,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,yCAAyC,CACjD,CAAA"}

package/dist/validation.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export const storefrontVerificationChannelSchema = z.enum(["email", "sms"]);
+export const storefrontVerificationStatusSchema = z.enum([
+    "pending",
+    "verified",
+    "expired",
+    "failed",
+    "cancelled",
+]);
+const purposeSchema = z.string().trim().min(1).max(100).default("contact_confirmation");
+const metadataSchema = z.record(z.string(), z.unknown()).optional().nullable();
+export const startEmailVerificationChallengeSchema = z.object({
+    email: z.email(),
+    purpose: purposeSchema,
+    locale: z.string().trim().min(2).max(16).optional().nullable(),
+    metadata: metadataSchema,
+});
+export const startSmsVerificationChallengeSchema = z.object({
+    phone: z.string().trim().min(6).max(32),
+    purpose: purposeSchema,
+    locale: z.string().trim().min(2).max(16).optional().nullable(),
+    metadata: metadataSchema,
+});
+export const confirmEmailVerificationChallengeSchema = z.object({
+    email: z.email(),
+    code: z
+        .string()
+        .trim()
+        .regex(/^\d{4,8}$/),
+    purpose: purposeSchema,
+});
+export const confirmSmsVerificationChallengeSchema = z.object({
+    phone: z.string().trim().min(6).max(32),
+    code: z
+        .string()
+        .trim()
+        .regex(/^\d{4,8}$/),
+    purpose: purposeSchema,
+});
+export const storefrontVerificationChallengeRecordSchema = z.object({
+    id: z.string(),
+    channel: storefrontVerificationChannelSchema,
+    destination: z.string(),
+    purpose: z.string(),
+    status: storefrontVerificationStatusSchema,
+    expiresAt: z.date(),
+    verifiedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export const storefrontVerificationStartResultSchema = storefrontVerificationChallengeRecordSchema;
+export const storefrontVerificationConfirmResultSchema = storefrontVerificationChallengeRecordSchema.extend({
+    status: z.literal("verified"),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/storefront-verification",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -34,10 +34,10 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/core": "0.24.1",
-    "@voyantjs/db": "0.24.1",
-    "@voyantjs/hono": "0.24.1",
-    "@voyantjs/notifications": "0.24.1"
+    "@voyantjs/core": "0.24.3",
+    "@voyantjs/db": "0.24.3",
+    "@voyantjs/hono": "0.24.3",
+    "@voyantjs/notifications": "0.24.3"
   },
   "devDependencies": {
     "typescript": "^6.0.2",
@@ -66,7 +66,7 @@
     "lint": "biome check src/",
     "test": "vitest run",
     "build": "pnpm run clean && tsc -p tsconfig.json",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"