@voyantjs/plugin-netopia 0.5.0 → 0.6.2

package/README.md

@@ -1,8 +1,19 @@
 # `@voyantjs/plugin-netopia`
 
-Netopia hosted-card payment support for Voyant finance.
+Netopia hosted-card payment adapter bundle for Voyant finance.
 
-This package sits on top of `@voyantjs/finance` and its `payment_sessions` model. It does not replace finance state. It starts a hosted Netopia checkout, stores provider references on the session, and reconciles callback payloads back into Voyant payments, captures, authorizations, invoices, and booking payment schedules.
+This package sits on top of `@voyantjs/finance` and its `payment_sessions`
+model. It does not replace finance state.
+
+Architecturally, this package is primarily:
+
+- a Netopia payment adapter
+- a finance extension
+- an optional packaged Hono bundle when an app wants one installable entrypoint
+
+It starts a hosted Netopia checkout, stores provider references on the session,
+and reconciles callback payloads back into Voyant payments, captures,
+authorizations, invoices, and booking payment schedules.
 
 ## Environment
 
@@ -29,23 +40,29 @@ Mounted as a finance extension, the package exposes:
 
 ## Checkout integration
 
-If you use `@voyantjs/checkout`, the plugin now also exports
+If you use `@voyantjs/checkout`, the package also exports
 `createNetopiaCheckoutStarter()`. That lets checkout create the payment session
 and start the Netopia redirect flow in one request while keeping provider
 startup optional in core checkout.
 
-Because this is a finance extension, these routes mount under the finance module path in the app.
+Because this is a finance extension, these routes mount under the finance module
+path in the app.
 
 ## Usage
 
 ```ts
-import { createNetopiaFinanceExtension } from "@voyantjs/plugin-netopia"
+import { createNetopiaFinanceAdapter } from "@voyantjs/plugin-netopia"
 
-const netopiaFinanceExtension = createNetopiaFinanceExtension()
+const netopiaFinanceExtension = createNetopiaFinanceAdapter()
 ```
 
 Then include the returned extension in `createApp({ extensions: [...] })`.
 
+If you want the packaged distribution helper instead, use
+`createNetopiaAdapterBundle()` or `netopiaHonoPlugin()`. Those are optional
+distribution helpers over the adapter/extension surfaces above; the adapter and
+finance extension remain the main runtime seams.
+
 ## Flow
 
 1. Either create a finance `payment_session` yourself, or use one of the collect routes to create one from a booking schedule, guarantee, or invoice.
@@ -53,7 +70,7 @@ Then include the returned extension in `createApp({ extensions: [...] })`.
 3. Redirect the customer to the returned provider `paymentURL`.
 4. Optionally send a payment-link or invoice notification as part of the collect flow.
 5. Netopia calls the callback route.
-6. The plugin completes, fails, or updates the session in finance.
+6. The adapter completes, fails, or updates the session in finance.
 
 ## Notes
 

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,qBAAqB,EACrB,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AAEnB,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAA;CAC5F;AAED,MAAM,WAAW,oBACf,SAAQ,IAAI,CAAC,6BAA6B,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChE,KAAK,CAAC,EAAE,YAAY,CAAA;CACrB;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,OAAO,GAAE,qBAA0B,GAClC,6BAA6B,CA0B/B;AAMD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,gBAAgB,CA+CnF"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,qBAAqB,EACrB,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AAGnB,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAA;CAC5F;AAED,MAAM,WAAW,oBACf,SAAQ,IAAI,CAAC,6BAA6B,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAChE,KAAK,CAAC,EAAE,YAAY,CAAA;CACrB;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,OAAO,GAAE,qBAA0B,GAClC,6BAA6B,CAuC/B;AAMD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,gBAAgB,CA+CnF"}

package/dist/client.js

@@ -1,3 +1,5 @@
+import { ZodError } from "zod";
+import { resolvedNetopiaRuntimeOptionsSchema } from "./validation.js";
 export function resolveNetopiaRuntimeOptions(bindings, options = {}) {
     const env = bindings ?? {};
     const apiUrl = options.apiUrl ?? coerceString(env.NETOPIA_URL);
@@ -15,18 +17,32 @@ export function resolveNetopiaRuntimeOptions(bindings, options = {}) {
         throw new Error("Missing Netopia config: NETOPIA_NOTIFY_URL");
     if (!redirectUrl)
         throw new Error("Missing Netopia config: NETOPIA_REDIRECT_URL");
-    return {
-        apiUrl,
-        apiKey,
-        posSignature,
-        notifyUrl,
-        redirectUrl,
-        emailTemplate: options.emailTemplate ?? "confirm",
-        language: options.language ?? "ro",
-        successStatuses: options.successStatuses ?? [3, 5],
-        processingStatuses: options.processingStatuses ?? [1, 15],
-        fetch: options.fetch,
-    };
+    try {
+        return resolvedNetopiaRuntimeOptionsSchema.parse({
+            apiUrl,
+            apiKey,
+            posSignature,
+            notifyUrl,
+            redirectUrl,
+            emailTemplate: options.emailTemplate,
+            language: options.language,
+            successStatuses: options.successStatuses,
+            processingStatuses: options.processingStatuses,
+            fetch: options.fetch,
+        });
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            const detail = error.issues
+                .map((issue) => {
+                const path = issue.path.join(".") || "runtimeOptions";
+                return `${path}: ${issue.message}`;
+            })
+                .join("; ");
+            throw new Error(`Invalid Netopia runtime options: ${detail}`);
+        }
+        throw error;
+    }
 }
 function coerceString(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { createNetopiaCheckoutStarter } from "./checkout.js";
 export { createNetopiaClient, type NetopiaClientApi, type NetopiaClientOptions, resolveNetopiaRuntimeOptions, } from "./client.js";
-export { createNetopiaFinanceExtension, createNetopiaFinanceRoutes, netopiaFinanceExtension, netopiaHonoPlugin, } from "./plugin.js";
+export type { NetopiaNotificationRuntime, NetopiaNotificationRuntimeOptions, } from "./notification-runtime.js";
+export { buildNetopiaNotificationRuntime } from "./notification-runtime.js";
+export { createNetopiaFinanceExtension, createNetopiaFinanceExtension as createNetopiaFinanceAdapter, createNetopiaFinanceRoutes, NETOPIA_RUNTIME_CONTAINER_KEY, netopiaFinanceExtension, netopiaHonoPlugin as createNetopiaAdapterBundle, netopiaHonoPlugin, } from "./plugin.js";
 export { deriveNetopiaOrderId, mapNetopiaPaymentStatus, type NetopiaCallbackResult, type NetopiaCollectPaymentResult, type NetopiaStartPaymentResult, netopiaService, } from "./service.js";
 export type { NetopiaBillingAddress, NetopiaBrowserData, NetopiaFetch, NetopiaInstallments, NetopiaPaymentInstrument, NetopiaPaymentOptions, NetopiaProductLine, NetopiaRuntimeOptions, NetopiaStartPaymentInput, NetopiaStartPaymentRequest, NetopiaStartPaymentResponse, NetopiaWebhookPayload, ResolvedNetopiaRuntimeOptions, } from "./types.js";
-export { netopiaBillingAddressSchema, netopiaBrowserDataSchema, netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaInstallmentsSchema, netopiaPaymentInstrumentSchema, netopiaPaymentOptionsSchema, netopiaProductLineSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, } from "./validation.js";
+export { netopiaBillingAddressSchema, netopiaBrowserDataSchema, netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaInstallmentsSchema, netopiaPaymentInstrumentSchema, netopiaPaymentOptionsSchema, netopiaProductLineSchema, netopiaRuntimeOptionsSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, resolvedNetopiaRuntimeOptionsSchema, } from "./validation.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAC5D,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,4BAA4B,GAC7B,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,6BAA6B,EAC7B,0BAA0B,EAC1B,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,cAAc,GACf,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,EACxB,oCAAoC,EACpC,mCAAmC,EACnC,2BAA2B,EAC3B,yBAAyB,EACzB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,gCAAgC,EAChC,2BAA2B,GAC5B,MAAM,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAC5D,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,4BAA4B,GAC7B,MAAM,aAAa,CAAA;AACpB,YAAY,EACV,0BAA0B,EAC1B,iCAAiC,GAClC,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAA;AAC3E,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,IAAI,2BAA2B,EAC5D,0BAA0B,EAC1B,6BAA6B,EAC7B,uBAAuB,EACvB,iBAAiB,IAAI,0BAA0B,EAC/C,iBAAiB,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC9B,cAAc,GACf,MAAM,cAAc,CAAA;AACrB,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,YAAY,EACZ,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,EAC3B,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,EACxB,oCAAoC,EACpC,mCAAmC,EACnC,2BAA2B,EAC3B,yBAAyB,EACzB,8BAA8B,EAC9B,2BAA2B,EAC3B,wBAAwB,EACxB,2BAA2B,EAC3B,gCAAgC,EAChC,2BAA2B,EAC3B,mCAAmC,GACpC,MAAM,iBAAiB,CAAA"}

package/dist/index.js

@@ -1,5 +1,6 @@
 export { createNetopiaCheckoutStarter } from "./checkout.js";
 export { createNetopiaClient, resolveNetopiaRuntimeOptions, } from "./client.js";
-export { createNetopiaFinanceExtension, createNetopiaFinanceRoutes, netopiaFinanceExtension, netopiaHonoPlugin, } from "./plugin.js";
+export { buildNetopiaNotificationRuntime } from "./notification-runtime.js";
+export { createNetopiaFinanceExtension, createNetopiaFinanceExtension as createNetopiaFinanceAdapter, createNetopiaFinanceRoutes, NETOPIA_RUNTIME_CONTAINER_KEY, netopiaFinanceExtension, netopiaHonoPlugin as createNetopiaAdapterBundle, netopiaHonoPlugin, } from "./plugin.js";
 export { deriveNetopiaOrderId, mapNetopiaPaymentStatus, netopiaService, } from "./service.js";
-export { netopiaBillingAddressSchema, netopiaBrowserDataSchema, netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaInstallmentsSchema, netopiaPaymentInstrumentSchema, netopiaPaymentOptionsSchema, netopiaProductLineSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, } from "./validation.js";
+export { netopiaBillingAddressSchema, netopiaBrowserDataSchema, netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaInstallmentsSchema, netopiaPaymentInstrumentSchema, netopiaPaymentOptionsSchema, netopiaProductLineSchema, netopiaRuntimeOptionsSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, resolvedNetopiaRuntimeOptionsSchema, } from "./validation.js";

package/dist/notification-runtime.d.ts

@@ -0,0 +1,10 @@
+import { type NotificationProvider, type NotificationService } from "@voyantjs/notifications";
+import type { NetopiaRuntimeOptions } from "./types.js";
+export type NetopiaNotificationRuntime = {
+    dispatcher: NotificationService;
+};
+export type NetopiaNotificationRuntimeOptions = Pick<NetopiaRuntimeOptions, "resolveNotificationProviders"> & {
+    notificationProviders?: ReadonlyArray<NotificationProvider>;
+};
+export declare function buildNetopiaNotificationRuntime(bindings: Record<string, unknown> | undefined, runtimeOptions?: NetopiaNotificationRuntimeOptions, dispatcherOverride?: NotificationService): NetopiaNotificationRuntime;
+//# sourceMappingURL=notification-runtime.d.ts.map

package/dist/notification-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notification-runtime.d.ts","sourceRoot":"","sources":["../src/notification-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,EAAE,mBAAmB,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAClD,qBAAqB,EACrB,8BAA8B,CAC/B,GAAG;IACF,qBAAqB,CAAC,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;CAC5D,CAAA;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,cAAc,GAAE,iCAAsC,EACtD,kBAAkB,CAAC,EAAE,mBAAmB,GACvC,0BAA0B,CAe5B"}

package/dist/notification-runtime.js

@@ -0,0 +1,14 @@
+import { createDefaultNotificationProviders, createNotificationService, } from "@voyantjs/notifications";
+export function buildNetopiaNotificationRuntime(bindings, runtimeOptions = {}, dispatcherOverride) {
+    if (dispatcherOverride) {
+        return {
+            dispatcher: dispatcherOverride,
+        };
+    }
+    const providers = runtimeOptions.resolveNotificationProviders?.(bindings ?? {}) ??
+        runtimeOptions.notificationProviders ??
+        createDefaultNotificationProviders(bindings ?? {});
+    return {
+        dispatcher: createNotificationService(providers),
+    };
+}

package/dist/plugin.d.ts

@@ -1,14 +1,17 @@
-import { type HonoPlugin } from "@voyantjs/hono";
+import type { ModuleContainer } from "@voyantjs/core";
+import { type HonoBundle } from "@voyantjs/hono";
 import type { HonoExtension } from "@voyantjs/hono/module";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 import type { NetopiaRuntimeOptions } from "./types.js";
 type Env = {
     Bindings: Record<string, unknown>;
     Variables: {
+        container: ModuleContainer;
         db: PostgresJsDatabase;
         userId?: string;
     };
 };
+export declare const NETOPIA_RUNTIME_CONTAINER_KEY = "providers.netopia.runtime";
 export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptions): import("hono/hono-base").HonoBase<Env, {
     "/providers/netopia/payment-sessions/:sessionId/start": {
         $post: {
@@ -20,24 +23,24 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
             output: {
                 data: {
                     session: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "expired" | "cancelled" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        createdAt: string;
+                        updatedAt: string;
+                        expiresAt: string | null;
+                        status: "pending" | "expired" | "cancelled" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        currency: string;
+                        notes: string | null;
                         expiredAt: string | null;
                         cancelledAt: string | null;
                         completedAt: string | null;
-                        createdAt: string;
-                        updatedAt: string;
                         bookingId: string | null;
-                        notes: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        expiresAt: string | null;
                         provider: string | null;
                         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
                         targetId: string | null;
                         orderId: string | null;
-                        currency: string;
                         invoiceId: string | null;
                         amountCents: number;
                         bookingPaymentScheduleId: string | null;
@@ -146,19 +149,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
             output: {
                 data: {
                     paymentSessionNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -179,19 +182,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     invoiceNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -212,24 +215,24 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     session: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "expired" | "cancelled" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        createdAt: string;
+                        updatedAt: string;
+                        expiresAt: string | null;
+                        status: "pending" | "expired" | "cancelled" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        currency: string;
+                        notes: string | null;
                         expiredAt: string | null;
                         cancelledAt: string | null;
                         completedAt: string | null;
-                        createdAt: string;
-                        updatedAt: string;
                         bookingId: string | null;
-                        notes: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        expiresAt: string | null;
                         provider: string | null;
                         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
                         targetId: string | null;
                         orderId: string | null;
-                        currency: string;
                         invoiceId: string | null;
                         amountCents: number;
                         bookingPaymentScheduleId: string | null;
@@ -291,7 +294,7 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                 error: string;
             };
             outputFormat: "json";
-            status: 500 | 404 | 409 | 502;
+            status: 404 | 409 | 500 | 502;
         };
     };
 } & {
@@ -307,19 +310,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
             output: {
                 data: {
                     paymentSessionNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -340,19 +343,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     invoiceNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -373,24 +376,24 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     session: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "expired" | "cancelled" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        createdAt: string;
+                        updatedAt: string;
+                        expiresAt: string | null;
+                        status: "pending" | "expired" | "cancelled" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        currency: string;
+                        notes: string | null;
                         expiredAt: string | null;
                         cancelledAt: string | null;
                         completedAt: string | null;
-                        createdAt: string;
-                        updatedAt: string;
                         bookingId: string | null;
-                        notes: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        expiresAt: string | null;
                         provider: string | null;
                         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
                         targetId: string | null;
                         orderId: string | null;
-                        currency: string;
                         invoiceId: string | null;
                         amountCents: number;
                         bookingPaymentScheduleId: string | null;
@@ -452,7 +455,7 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                 error: string;
             };
             outputFormat: "json";
-            status: 500 | 404 | 409 | 502;
+            status: 404 | 409 | 500 | 502;
         };
     };
 } & {
@@ -466,19 +469,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
             output: {
                 data: {
                     paymentSessionNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -499,19 +502,19 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     invoiceNotification: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "cancelled" | "pending" | "failed" | "sent";
-                        personId: string | null;
-                        organizationId: string | null;
                         createdAt: string;
                         updatedAt: string;
+                        organizationId: string | null;
+                        status: "pending" | "cancelled" | "failed" | "sent";
+                        personId: string | null;
                         bookingId: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
                         channel: "email" | "sms";
                         provider: string;
-                        targetType: "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "organization" | "person" | "payment_session";
+                        targetType: "organization" | "other" | "booking" | "invoice" | "booking_payment_schedule" | "booking_guarantee" | "person" | "payment_session";
                         targetId: string | null;
                         templateId: string | null;
                         invoiceId: string | null;
@@ -532,24 +535,24 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                         scheduledFor: string | null;
                     } | null;
                     session: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "expired" | "cancelled" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        createdAt: string;
+                        updatedAt: string;
+                        expiresAt: string | null;
+                        status: "pending" | "expired" | "cancelled" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        currency: string;
+                        notes: string | null;
                         expiredAt: string | null;
                         cancelledAt: string | null;
                         completedAt: string | null;
-                        createdAt: string;
-                        updatedAt: string;
                         bookingId: string | null;
-                        notes: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        expiresAt: string | null;
                         provider: string | null;
                         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
                         targetId: string | null;
                         orderId: string | null;
-                        currency: string;
                         invoiceId: string | null;
                         amountCents: number;
                         bookingPaymentScheduleId: string | null;
@@ -609,7 +612,7 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                 error: string;
             };
             outputFormat: "json";
-            status: 500 | 404 | 409 | 502;
+            status: 404 | 409 | 500 | 502;
         };
     };
 } & {
@@ -621,24 +624,24 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
                     action: "processing" | "completed" | "failed" | "ignored";
                     reason?: string | undefined;
                     session: {
+                        metadata: {
+                            [x: string]: import("hono/utils/types").JSONValue;
+                        } | null;
                         id: string;
-                        status: "expired" | "cancelled" | "pending" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        createdAt: string;
+                        updatedAt: string;
+                        expiresAt: string | null;
+                        status: "pending" | "expired" | "cancelled" | "failed" | "paid" | "requires_redirect" | "processing" | "authorized";
+                        currency: string;
+                        notes: string | null;
                         expiredAt: string | null;
                         cancelledAt: string | null;
                         completedAt: string | null;
-                        createdAt: string;
-                        updatedAt: string;
                         bookingId: string | null;
-                        notes: string | null;
-                        metadata: {
-                            [x: string]: import("hono/utils/types").JSONValue;
-                        } | null;
-                        expiresAt: string | null;
                         provider: string | null;
                         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";
                         targetId: string | null;
                         orderId: string | null;
-                        currency: string;
                         invoiceId: string | null;
                         amountCents: number;
                         bookingPaymentScheduleId: string | null;
@@ -703,7 +706,9 @@ export declare function createNetopiaFinanceRoutes(options?: NetopiaRuntimeOptio
     };
 }, "/", "/providers/netopia/config">;
 export declare function createNetopiaFinanceExtension(options?: NetopiaRuntimeOptions): HonoExtension;
-export declare function netopiaHonoPlugin(options?: NetopiaRuntimeOptions): HonoPlugin;
+export declare function netopiaHonoBundle(options?: NetopiaRuntimeOptions): HonoBundle;
+/** @deprecated Prefer {@link netopiaHonoBundle}. */
+export declare const netopiaHonoPlugin: typeof netopiaHonoBundle;
 export declare const netopiaFinanceExtension: HonoExtension;
 export {};
 //# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AASvD,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA2I7E;AAOD,wBAAgB,6BAA6B,CAAC,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAKhG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAMjF;AAED,eAAO,MAAM,uBAAuB,eAAkC,CAAA"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,EAAoB,KAAK,UAAU,EAAiB,MAAM,gBAAgB,CAAA;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,OAAO,KAAK,EAAE,qBAAqB,EAAiC,MAAM,YAAY,CAAA;AAStF,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,eAAO,MAAM,6BAA6B,8BAA8B,CAAA;AAkBxE,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAmJ7E;AAOD,wBAAgB,6BAA6B,CAAC,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAKhG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAYjF;AAED,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,0BAAoB,CAAA;AAElD,eAAO,MAAM,uBAAuB,eAAkC,CAAA"}

package/dist/plugin.js

@@ -1,8 +1,20 @@
-import { defineHonoPlugin } from "@voyantjs/hono";
+import { defineHonoBundle, parseJsonBody } from "@voyantjs/hono";
 import { Hono } from "hono";
 import { resolveNetopiaRuntimeOptions } from "./client.js";
 import { netopiaService } from "./service.js";
 import { netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, } from "./validation.js";
+export const NETOPIA_RUNTIME_CONTAINER_KEY = "providers.netopia.runtime";
+function getNetopiaRuntime(bindings, options, resolveFromContainer) {
+    if (resolveFromContainer) {
+        try {
+            return resolveFromContainer(NETOPIA_RUNTIME_CONTAINER_KEY);
+        }
+        catch {
+            // Fall through to per-request resolution when bootstrap has not run.
+        }
+    }
+    return resolveNetopiaRuntimeOptions(bindings, options);
+}
 export function createNetopiaFinanceRoutes(options = {}) {
     const handleNetopiaError = (message) => {
         if (message.includes("not found") ||
@@ -24,11 +36,13 @@ export function createNetopiaFinanceRoutes(options = {}) {
         }
         return { status: 502, message };
     };
+    const resolveRuntime = (c) => getNetopiaRuntime(c.env, options, (key) => c.var.container.resolve(key));
     return new Hono()
         .post("/providers/netopia/payment-sessions/:sessionId/start", async (c) => {
         try {
-            const data = netopiaStartPaymentSessionSchema.parse(await c.req.json());
-            const result = await netopiaService.startPaymentSession(c.get("db"), c.req.param("sessionId"), data, options, undefined, c.env);
+            const data = await parseJsonBody(c, netopiaStartPaymentSessionSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.startPaymentSession(c.get("db"), c.req.param("sessionId"), data, runtime, undefined);
             return c.json({ data: result }, 201);
         }
         catch (error) {
@@ -47,8 +61,9 @@ export function createNetopiaFinanceRoutes(options = {}) {
     })
         .post("/providers/netopia/bookings/:bookingId/payment-schedules/:scheduleId/collect", async (c) => {
         try {
-            const data = netopiaCollectBookingScheduleSchema.parse(await c.req.json());
-            const result = await netopiaService.collectBookingSchedule(c.get("db"), c.req.param("scheduleId"), data, options, undefined, undefined, c.env);
+            const data = await parseJsonBody(c, netopiaCollectBookingScheduleSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectBookingSchedule(c.get("db"), c.req.param("scheduleId"), data, runtime, undefined, undefined, c.env);
             return c.json({ data: result }, 201);
         }
         catch (error) {
@@ -59,8 +74,9 @@ export function createNetopiaFinanceRoutes(options = {}) {
     })
         .post("/providers/netopia/bookings/:bookingId/guarantees/:guaranteeId/collect", async (c) => {
         try {
-            const data = netopiaCollectBookingGuaranteeSchema.parse(await c.req.json());
-            const result = await netopiaService.collectBookingGuarantee(c.get("db"), c.req.param("guaranteeId"), data, options, undefined, undefined, c.env);
+            const data = await parseJsonBody(c, netopiaCollectBookingGuaranteeSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectBookingGuarantee(c.get("db"), c.req.param("guaranteeId"), data, runtime, undefined, undefined, c.env);
             return c.json({ data: result }, 201);
         }
         catch (error) {
@@ -71,8 +87,9 @@ export function createNetopiaFinanceRoutes(options = {}) {
     })
         .post("/providers/netopia/invoices/:invoiceId/collect", async (c) => {
         try {
-            const data = netopiaCollectInvoiceSchema.parse(await c.req.json());
-            const result = await netopiaService.collectInvoice(c.get("db"), c.req.param("invoiceId"), data, options, undefined, undefined, c.env);
+            const data = await parseJsonBody(c, netopiaCollectInvoiceSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectInvoice(c.get("db"), c.req.param("invoiceId"), data, runtime, undefined, undefined, c.env);
             return c.json({ data: result }, 201);
         }
         catch (error) {
@@ -82,13 +99,14 @@ export function createNetopiaFinanceRoutes(options = {}) {
         }
     })
         .post("/providers/netopia/callback", async (c) => {
-        const payload = netopiaWebhookPayloadSchema.parse(await c.req.json());
-        const result = await netopiaService.handleCallback(c.get("db"), payload, options, c.env);
+        const payload = await parseJsonBody(c, netopiaWebhookPayloadSchema);
+        const runtime = resolveRuntime(c);
+        const result = await netopiaService.handleCallback(c.get("db"), payload, runtime);
         return c.json({ data: result });
     })
         .get("/providers/netopia/config", async (c) => {
         try {
-            const runtime = resolveNetopiaRuntimeOptions(c.env, options);
+            const runtime = resolveRuntime(c);
             return c.json({
                 data: {
                     apiUrl: runtime.apiUrl,
@@ -117,11 +135,16 @@ export function createNetopiaFinanceExtension(options = {}) {
         routes: createNetopiaFinanceRoutes(options),
     };
 }
-export function netopiaHonoPlugin(options = {}) {
-    return defineHonoPlugin({
+export function netopiaHonoBundle(options = {}) {
+    return defineHonoBundle({
         name: "netopia",
         version: "0.1.0",
+        bootstrap: ({ bindings, container }) => {
+            container.register(NETOPIA_RUNTIME_CONTAINER_KEY, resolveNetopiaRuntimeOptions(bindings, options));
+        },
         extensions: [createNetopiaFinanceExtension(options)],
     });
 }
+/** @deprecated Prefer {@link netopiaHonoBundle}. */
+export const netopiaHonoPlugin = netopiaHonoBundle;
 export const netopiaFinanceExtension = createNetopiaFinanceExtension();

package/dist/service-shared.d.ts

@@ -1,5 +1,5 @@
 import { financeService, type PaymentSession } from "@voyantjs/finance";
-import { type NotificationDelivery, type NotificationService } from "@voyantjs/notifications";
+import type { NotificationDelivery, NotificationService } from "@voyantjs/notifications";
 import type { z } from "zod";
 import type { NetopiaProductLine, NetopiaRuntimeOptions, NetopiaStartPaymentResponse, ResolvedNetopiaRuntimeOptions } from "./types.js";
 import type { netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema } from "./validation.js";

package/dist/service-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-shared.d.ts","sourceRoot":"","sources":["../src/service-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,oCAAoC,EACpC,mCAAmC,EACnC,2BAA2B,EAC5B,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,cAAc,CAAA;IACvB,gBAAgB,EAAE,2BAA2B,CAAA;IAC7C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC5E,0BAA0B,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACvD,mBAAmB,EAAE,oBAAoB,GAAG,IAAI,CAAA;CACjD;AAED,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,oCAAoC,CAC5C,CAAA;AACD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,UAE1C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,UAE3C;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,UAEjD;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,MAAM,GAClB,kBAAkB,EAAE,CAQtB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,UAE3D;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,6BAA6B,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GACrF,WAAW,GAAG,YAAY,GAAG,QAAQ,CAIvC;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,cAAc,EAAE,qBAAqB,EACrC,kBAAkB,CAAC,EAAE,mBAAmB,uBAUzC;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"service-shared.d.ts","sourceRoot":"","sources":["../src/service-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AACxF,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,oCAAoC,EACpC,mCAAmC,EACnC,2BAA2B,EAC5B,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,cAAc,CAAA;IACvB,gBAAgB,EAAE,2BAA2B,CAAA;IAC7C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC5E,0BAA0B,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACvD,mBAAmB,EAAE,oBAAoB,GAAG,IAAI,CAAA;CACjD;AAED,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,oCAAoC,CAC5C,CAAA;AACD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,UAE1C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,UAE3C;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,UAEjD;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,MAAM,GAClB,kBAAkB,EAAE,CAQtB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,UAE3D;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,6BAA6B,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GACrF,WAAW,GAAG,YAAY,GAAG,QAAQ,CAIvC;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,cAAc,EAAE,qBAAqB,EACrC,kBAAkB,CAAC,EAAE,mBAAmB,uBAGzC;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/service-shared.js

@@ -1,5 +1,5 @@
 import { financeService } from "@voyantjs/finance";
-import { createDefaultNotificationProviders, createNotificationService, } from "@voyantjs/notifications";
+import { buildNetopiaNotificationRuntime } from "./notification-runtime.js";
 export function centsToAmount(cents) {
     return Number((cents / 100).toFixed(2));
 }
@@ -35,10 +35,6 @@ export function mapNetopiaPaymentStatus(status, options) {
     return "failed";
 }
 export function resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride) {
-    if (dispatcherOverride) {
-        return dispatcherOverride;
-    }
-    return createNotificationService(runtimeOptions.resolveNotificationProviders?.(bindings ?? {}) ??
-        createDefaultNotificationProviders(bindings ?? {}));
+    return buildNetopiaNotificationRuntime(bindings, runtimeOptions, dispatcherOverride).dispatcher;
 }
 export { financeService };

package/dist/validation.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import type { NetopiaFetch } from "./types.js";
 export declare const netopiaBillingAddressSchema: z.ZodObject<{
     email: z.ZodString;
     phone: z.ZodString;
@@ -34,6 +35,31 @@ export declare const netopiaPaymentInstrumentSchema: z.ZodObject<{
     token: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const netopiaBrowserDataSchema: z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodString>>;
+export declare const netopiaRuntimeOptionsSchema: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    posSignature: z.ZodOptional<z.ZodString>;
+    notifyUrl: z.ZodOptional<z.ZodString>;
+    redirectUrl: z.ZodOptional<z.ZodString>;
+    emailTemplate: z.ZodOptional<z.ZodString>;
+    language: z.ZodOptional<z.ZodString>;
+    successStatuses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    processingStatuses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    fetch: z.ZodOptional<z.ZodCustom<NetopiaFetch | undefined, NetopiaFetch | undefined>>;
+    resolveNotificationProviders: z.ZodOptional<z.ZodCustom<((bindings: Record<string, unknown>) => ReadonlyArray<import("@voyantjs/notifications").NotificationProvider>) | undefined, ((bindings: Record<string, unknown>) => ReadonlyArray<import("@voyantjs/notifications").NotificationProvider>) | undefined>>;
+}, z.core.$strip>;
+export declare const resolvedNetopiaRuntimeOptionsSchema: z.ZodObject<{
+    apiUrl: z.ZodString;
+    apiKey: z.ZodString;
+    posSignature: z.ZodString;
+    notifyUrl: z.ZodString;
+    redirectUrl: z.ZodString;
+    emailTemplate: z.ZodDefault<z.ZodString>;
+    language: z.ZodDefault<z.ZodString>;
+    successStatuses: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    processingStatuses: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    fetch: z.ZodOptional<z.ZodCustom<NetopiaFetch | undefined, NetopiaFetch | undefined>>;
+}, z.core.$strip>;
 export declare const netopiaStartPaymentSessionSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     notifyUrl: z.ZodOptional<z.ZodString>;

package/dist/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAUtC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;iBAMnC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;iBAOzC,CAAA;AAEF,eAAO,MAAM,wBAAwB,sDAA8C,CAAA;AAEnF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB3C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;iBA4BtC,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI9C,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKtC,CAAA"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,YAAY,EAAyB,MAAM,YAAY,CAAA;AAErE,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAUtC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;iBAMnC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;;iBAGpC,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;iBAOzC,CAAA;AAEF,eAAO,MAAM,wBAAwB,sDAA8C,CAAA;AAkBnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBAYtC,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;iBAW9C,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkB3C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;iBA4BtC,CAAA;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI9C,CAAA;AAEF,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI/C,CAAA;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKtC,CAAA"}

package/dist/validation.js

@@ -36,6 +36,36 @@ export const netopiaPaymentInstrumentSchema = z.object({
     token: z.string().optional(),
 });
 export const netopiaBrowserDataSchema = z.record(z.string(), z.string().optional());
+const optionalRuntimeUrl = z.string().trim().url().optional();
+const optionalRuntimeString = z.string().trim().min(1).optional();
+const optionalIntegerArray = z.array(z.number().int()).min(1).optional();
+const optionalFetch = z.custom((value) => value === undefined || typeof value === "function", "Expected a fetch implementation function");
+const optionalProviderResolver = z.custom((value) => value === undefined || typeof value === "function", "Expected a notification provider resolver function");
+export const netopiaRuntimeOptionsSchema = z.object({
+    apiUrl: optionalRuntimeUrl,
+    apiKey: optionalRuntimeString,
+    posSignature: optionalRuntimeString,
+    notifyUrl: optionalRuntimeUrl,
+    redirectUrl: optionalRuntimeUrl,
+    emailTemplate: optionalRuntimeString,
+    language: optionalRuntimeString,
+    successStatuses: optionalIntegerArray,
+    processingStatuses: optionalIntegerArray,
+    fetch: optionalFetch.optional(),
+    resolveNotificationProviders: optionalProviderResolver.optional(),
+});
+export const resolvedNetopiaRuntimeOptionsSchema = z.object({
+    apiUrl: z.string().trim().url(),
+    apiKey: z.string().trim().min(1),
+    posSignature: z.string().trim().min(1),
+    notifyUrl: z.string().trim().url(),
+    redirectUrl: z.string().trim().url(),
+    emailTemplate: z.string().trim().min(1).default("confirm"),
+    language: z.string().trim().min(1).default("ro"),
+    successStatuses: z.array(z.number().int()).min(1).default([3, 5]),
+    processingStatuses: z.array(z.number().int()).min(1).default([1, 15]),
+    fetch: optionalFetch.optional(),
+});
 export const netopiaStartPaymentSessionSchema = z.object({
     description: z.string().optional(),
     notifyUrl: z.string().url().optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyantjs/plugin-netopia",
-  "version": "0.5.0",
+  "version": "0.6.2",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "exports": {
@@ -33,11 +33,11 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.10",
     "zod": "^4.3.6",
-    "@voyantjs/checkout": "0.5.0",
-    "@voyantjs/core": "0.5.0",
-    "@voyantjs/finance": "0.5.0",
-    "@voyantjs/hono": "0.5.0",
-    "@voyantjs/notifications": "0.5.0"
+    "@voyantjs/checkout": "0.6.2",
+    "@voyantjs/core": "0.6.2",
+    "@voyantjs/finance": "0.6.2",
+    "@voyantjs/hono": "0.6.2",
+    "@voyantjs/notifications": "0.6.2"
   },
   "devDependencies": {
     "typescript": "^6.0.2",