@forgezero/providers 0.1.22 → 0.1.24

package/dist/{binance.js → billing.js}

@@ -336,369 +336,270 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.22";
+var VERSION = "0.1.24";
 
-// src/http.ts
-class BudgetExhausted extends ProviderError {
-  host;
-  retryAfterMs;
-  constructor(host, retryAfterMs) {
-    super("RATE_BUDGET_EXHAUSTED", `The ${host} budget is spent. Retry in ${retryAfterMs}ms.`);
-    this.host = host;
-    this.retryAfterMs = retryAfterMs;
+// src/billing.ts
+var PAYMENT_PROVIDER_KEYS = ["stripe:v1", "paypal:v1", "razorpay:v1"];
+var paymentProviderDefinitions = [
+  {
+    id: "stripe",
+    label: "Stripe",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 4, maxLength: 64 },
+        mode: { type: "string", enum: ["test", "live"] }
+      },
+      required: ["providerApiVersion", "mode"],
+      additionalProperties: false
+    },
+    credentials: {
+      type: "object",
+      properties: {
+        secretKey: { type: "string", minLength: 16, maxLength: 512, writeOnly: true },
+        webhookSecret: { type: "string", minLength: 16, maxLength: 512, writeOnly: true }
+      },
+      required: ["secretKey", "webhookSecret"],
+      additionalProperties: false
+    },
+    methods: {}
+  },
+  {
+    id: "paypal",
+    label: "PayPal",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 2, maxLength: 64 },
+        environment: { type: "string", enum: ["sandbox", "live"] }
+      },
+      required: ["providerApiVersion", "environment"],
+      additionalProperties: false
+    },
+    credentials: {
+      type: "object",
+      properties: {
+        clientId: { type: "string", minLength: 10, maxLength: 512, writeOnly: true },
+        clientSecret: { type: "string", minLength: 10, maxLength: 512, writeOnly: true },
+        webhookId: { type: "string", minLength: 4, maxLength: 256, writeOnly: true }
+      },
+      required: ["clientId", "clientSecret", "webhookId"],
+      additionalProperties: false
+    },
+    methods: {}
+  },
+  {
+    id: "razorpay",
+    label: "Razorpay",
+    multiInstance: true,
+    config: {
+      type: "object",
+      properties: {
+        providerApiVersion: { type: "string", minLength: 2, maxLength: 64 },
+        mode: { type: "string", enum: ["test", "live"] }
+      },
+      required: ["providerApiVersion", "mode"],
+      additionalProperties: false
+    },
+    credentials: {
+      type: "object",
+      properties: {
+        keyId: { type: "string", minLength: 8, maxLength: 256, writeOnly: true },
+        keySecret: { type: "string", minLength: 8, maxLength: 512, writeOnly: true },
+        webhookSecret: { type: "string", minLength: 8, maxLength: 512, writeOnly: true }
+      },
+      required: ["keyId", "keySecret", "webhookSecret"],
+      additionalProperties: false
+    },
+    methods: {}
   }
-}
-var windows = new Map;
-function resetBudgets() {
-  windows.clear();
-}
-function spend(budget, cost, nowMs) {
-  const ceiling = Math.floor(budget.limit * (budget.headroom ?? 0.9));
-  const current = windows.get(budget.host);
-  if (!current || current.resetAtMs <= nowMs) {
-    windows.set(budget.host, { spent: cost, resetAtMs: nowMs + budget.windowMs });
-    return;
+];
+var billingService = defineService({
+  key: "billing",
+  methods: {
+    createHostedSetup: serviceMethod(),
+    completeHostedSetup: serviceMethod(),
+    createCustomer: serviceMethod(),
+    charge: serviceMethod(),
+    detachPaymentMethod: serviceMethod(),
+    verifyWebhook: serviceMethod(),
+    reconcile: serviceMethod()
   }
-  if (current.spent + cost > ceiling) {
-    throw new BudgetExhausted(budget.host, current.resetAtMs - nowMs);
+});
+function required(value, field, maximum = 512) {
+  const result = value.trim();
+  if (!result || result.length > maximum)
+    throw new Error(`PAYMENT_${field.toUpperCase()}_INVALID`);
+  return result;
+}
+function assertHostedInput(input) {
+  required(input.tenantKey, "tenant");
+  required(input.idempotencyKey, "idempotency", 200);
+  for (const [field, value] of [["return_url", input.returnUrl], ["cancel_url", input.cancelUrl]]) {
+    const url = new URL(required(value, field, 2048));
+    if (url.protocol !== "https:")
+      throw new Error(`PAYMENT_${field.toUpperCase()}_INVALID`);
   }
-  current.spent += cost;
 }
-function settle(host, reserved, actual) {
-  const current = windows.get(host);
-  if (!current)
-    return;
-  current.spent = Math.max(0, current.spent - reserved + actual);
+function assertChargeInput(input) {
+  required(input.tenantKey, "tenant");
+  required(input.invoiceKey, "invoice");
+  required(input.providerCustomerReference, "customer_reference");
+  required(input.providerPaymentMethodReference, "method_reference");
+  required(input.idempotencyKey, "idempotency", 200);
+  if (!/^[1-9][0-9]*$/.test(input.amountMinor))
+    throw new Error("PAYMENT_AMOUNT_INVALID");
+  if (input.currency !== "USD")
+    throw new Error("PAYMENT_CURRENCY_INVALID");
 }
-var budgetState = (host) => windows.get(host);
-function createHttpClient(config) {
-  const doFetch = config.fetch ?? globalThis.fetch;
-  const timeoutMs = config.timeoutMs ?? 1e4;
-  return {
-    async call(request) {
-      const reserved = request.weight ?? config.budget.defaultCost;
-      spend(config.budget, reserved, Date.now());
-      const url = new URL(config.baseUrl + request.path);
-      for (const [key, value] of Object.entries(request.query ?? {})) {
-        url.searchParams.set(key, String(value));
-      }
-      const controller = new AbortController;
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        const response = await doFetch(url.toString(), {
-          method: request.method ?? "GET",
-          signal: controller.signal,
-          headers: {
-            ...request.body === undefined ? {} : { "content-type": "application/json" },
-            ...request.headers
-          },
-          ...request.body === undefined ? {} : { body: JSON.stringify(request.body) }
-        });
-        const cost = config.costOf?.(response);
-        if (cost !== undefined)
-          settle(config.budget.host, reserved, cost);
-        const text = await response.text();
-        let body;
-        try {
-          body = text ? JSON.parse(text) : null;
-        } catch {
-          body = text;
-        }
-        if (!response.ok) {
-          throw Object.assign(new Error(`${config.budget.host} ${response.status}`), {
-            status: response.status,
-            body,
-            retryAfter: response.headers.get("retry-after")
-          });
-        }
-        return { status: response.status, body, cost };
-      } finally {
-        clearTimeout(timer);
-      }
-    },
-    budget: () => budgetState(config.budget.host)
-  };
+function assertSetupCompletion(input) {
+  required(input.tenantKey, "tenant");
+  required(input.setupReference, "setup_reference", 512);
+  required(input.idempotencyKey, "idempotency", 200);
 }
-var http = defineSingleMethodProvider({
-  id: "http",
-  method: "request",
-  label: "HTTP",
-  multiInstance: true,
-  credentials: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      apiKey: { type: "string", title: "API key", writeOnly: true },
-      apiSecret: { type: "string", title: "API secret", writeOnly: true }
-    }
-  },
-  config: {
-    type: "object",
-    additionalProperties: false,
-    required: ["baseUrl"],
-    properties: {
-      baseUrl: { type: "string", title: "Base URL" },
-      limit: { type: "integer", default: 6000, title: "Units per window" },
-      windowMs: { type: "integer", default: 60000 },
-      headroom: {
-        type: "number",
-        default: 0.9,
-        description: "Stop at this fraction of the limit. The venue's window boundary is not ours, and the penalty for crossing is a ban rather than a rejection."
-      }
-    }
-  },
-  async invoke(context, request) {
-    const config = context.config;
-    const client = createHttpClient({
-      baseUrl: config.baseUrl,
-      fetch: config.fetch,
-      costOf: config.costOf,
-      budget: {
-        host: new URL(config.baseUrl).host,
-        limit: config.limit ?? 6000,
-        windowMs: config.windowMs ?? 60000,
-        defaultCost: 1,
-        headroom: config.headroom
-      }
-    });
-    return client.call(request);
-  },
-  classify(error) {
-    const status = error.status;
-    if (status === 418)
-      return "backoff";
-    if (status === 429)
-      return "backoff";
-    if (status === 400 || status === 422)
-      return "terminal";
-    if (status === 401 || status === 403)
-      return "retryable";
-    return "retryable";
-  }
-});
-var binanceWeight = (response) => {
-  const header = response.headers.get("x-mbx-used-weight-1m");
-  return header === null ? undefined : Number(header);
-};
-var httpProviders = [http];
-
-// src/binance.ts
-import { parseAmount, formatAmount, zero, assetSpec } from "@forgezero/runtime/finance/money";
-import {
-  parseSymbol,
-  VenueError
-} from "@forgezero/runtime/finance/venues";
-var BUDGET_HOST = "binance";
-var DEFAULT_HOSTS = {
-  spot: "https://api.binance.com",
-  margin: "https://api.binance.com",
-  futures: "https://fapi.binance.com"
-};
-var binanceSymbol = (symbol) => {
-  const { base, quote } = parseSymbol(symbol);
-  return `${base}${quote}`;
-};
-var PATHS = {
-  spot: {
-    order: "/api/v3/order",
-    openOrders: "/api/v3/openOrders",
-    account: "/api/v3/account",
-    exchangeInfo: "/api/v3/exchangeInfo"
-  },
-  margin: {
-    order: "/sapi/v1/margin/order",
-    openOrders: "/sapi/v1/margin/openOrders",
-    account: "/sapi/v1/margin/account",
-    exchangeInfo: "/api/v3/exchangeInfo"
-  },
-  futures: {
-    order: "/fapi/v1/order",
-    openOrders: "/fapi/v1/openOrders",
-    account: "/fapi/v2/account",
-    exchangeInfo: "/fapi/v1/exchangeInfo"
+function assertHostedResult(value) {
+  const hostedUrl = new URL(required(value.hostedUrl, "hosted_url", 2048));
+  if (hostedUrl.protocol !== "https:" || hostedUrl.username || hostedUrl.password)
+    throw new Error("PAYMENT_HOSTED_URL_INVALID");
+  required(value.setupReference, "setup_reference", 512);
+  if (!Number.isSafeInteger(value.expiresAtTs) || value.expiresAtTs <= Date.now())
+    throw new Error("PAYMENT_SETUP_EXPIRY_INVALID");
+  return { ...value, hostedUrl: hostedUrl.toString() };
+}
+function assertCompletionResult(value) {
+  required(value.providerPaymentMethodReference, "method_reference", 512);
+  if (value.providerCustomerReference !== undefined)
+    required(value.providerCustomerReference, "customer_reference", 512);
+  const display = value.display;
+  if (!display || !["card", "bank", "upi", "paypal", "other"].includes(display.type))
+    throw new Error("PAYMENT_DISPLAY_INVALID");
+  for (const [field, item, maximum] of [
+    ["brand", display.brand, 80],
+    ["last4", display.last4, 8],
+    ["label", display.label, 160]
+  ]) {
+    if (item !== undefined)
+      required(item, `display_${field}`, maximum);
   }
-};
-function toOrderStatus(status) {
-  switch (status) {
-    case "NEW":
-    case "PENDING_NEW":
-      return "accepted";
-    case "PARTIALLY_FILLED":
-      return "partial";
-    case "FILLED":
-      return "filled";
-    case "CANCELED":
-    case "PENDING_CANCEL":
-    case "EXPIRED":
-    case "EXPIRED_IN_MATCH":
-      return "cancelled";
-    default:
-      return "rejected";
+  if (display.last4 !== undefined && !/^[A-Za-z0-9]{1,8}$/.test(display.last4))
+    throw new Error("PAYMENT_DISPLAY_LAST4_INVALID");
+  for (const value2 of [display.expiresMonth, display.expiresYear]) {
+    if (value2 !== undefined && !Number.isSafeInteger(value2))
+      throw new Error("PAYMENT_DISPLAY_EXPIRY_INVALID");
   }
+  if (display.expiresMonth !== undefined && (display.expiresMonth < 1 || display.expiresMonth > 12))
+    throw new Error("PAYMENT_DISPLAY_EXPIRY_INVALID");
+  return structuredClone(value);
 }
-var SIDE = { buy: "BUY", sell: "SELL" };
-var TYPE = { market: "MARKET", limit: "LIMIT", "stop-limit": "STOP_LOSS_LIMIT" };
-async function sign(secret, query) {
-  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const mac = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(query));
-  return [...new Uint8Array(mac)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+function assertCustomerResult(value) {
+  return { providerCustomerReference: required(value.providerCustomerReference, "customer_reference", 512) };
 }
-function createBinanceAdapter(options) {
-  const hosts = { ...DEFAULT_HOSTS, ...options.hosts };
-  const recvWindow = options.recvWindowMs ?? 5000;
-  const now = options.now ?? Date.now;
-  const clients = new Map;
-  const clientFor = (type) => {
-    const base = hosts[type];
-    const existing = clients.get(base);
-    if (existing)
-      return existing;
-    const client = createHttpClient({
-      baseUrl: base,
-      fetch: options.fetch,
-      costOf: binanceWeight,
-      budget: { host: BUDGET_HOST, limit: 6000, windowMs: 60000, defaultCost: 1, headroom: 0.9 }
-    });
-    clients.set(base, client);
-    return client;
-  };
-  async function signed(args) {
-    const entries = Object.entries(args.params).filter(([, value]) => value !== undefined);
-    const base = new URLSearchParams(entries.map(([name, value]) => [name, String(value)])).toString();
-    const withTiming = `${base}${base ? "&" : ""}recvWindow=${recvWindow}&timestamp=${now()}`;
-    const signature = await sign(options.credentials.apiSecret, withTiming);
-    const response = await clientFor(args.type).call({
-      path: `${args.path}?${withTiming}&signature=${signature}`,
-      method: args.method,
-      weight: args.weight,
-      headers: { "X-MBX-APIKEY": options.credentials.apiKey }
-    });
-    return response.body;
-  }
+function assertChargeResult(value) {
+  const providerAttemptReference = required(value.providerAttemptReference, "attempt_reference", 512);
+  if (!["succeeded", "failed", "pending"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
+  return { providerAttemptReference, status: value.status, ...failureCode ? { failureCode } : {} };
+}
+function assertWebhookResult(value) {
+  const providerEventId = required(value.providerEventId, "event_id", 512);
+  const eventType = required(value.eventType, "event_type", 160);
+  const resourceReference = required(value.resourceReference, "resource_reference", 512);
+  if (!["succeeded", "failed", "pending"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  if (!Number.isSafeInteger(value.occurredAtTs) || value.occurredAtTs < 0)
+    throw new Error("PAYMENT_EVENT_TIME_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
   return {
-    venue: "binance",
-    symbolFor: (symbol) => binanceSymbol(symbol),
-    async markets(type) {
-      const info = await clientFor(type).call({ path: PATHS[type].exchangeInfo, weight: 20 });
-      return (info.body.symbols ?? []).filter((entry) => entry.status === "TRADING").map((entry) => {
-        const filter = (name) => entry.filters.find((candidate) => candidate.filterType === name);
-        return {
-          venue: "binance",
-          type,
-          symbol: `${entry.baseAsset}/${entry.quoteAsset}`,
-          base: entry.baseAsset,
-          quote: entry.quoteAsset,
-          lotStep: filter("LOT_SIZE")?.stepSize ?? "0.00000001",
-          tickStep: filter("PRICE_FILTER")?.tickSize ?? "0.00000001",
-          minNotional: filter("NOTIONAL")?.minNotional ?? filter("MIN_NOTIONAL")?.minNotional ?? "0",
-          ...type === "spot" ? {} : { maxLeverage: 125 }
-        };
-      });
+    providerEventId,
+    eventType,
+    resourceReference,
+    status: value.status,
+    occurredAtTs: value.occurredAtTs,
+    ...failureCode ? { failureCode } : {}
+  };
+}
+function assertReconciliationResult(value) {
+  const providerAttemptReference = required(value.providerAttemptReference, "attempt_reference", 512);
+  if (!["succeeded", "failed", "pending", "not_found"].includes(value.status))
+    throw new Error("PAYMENT_STATUS_INVALID");
+  const failureCode = value.failureCode === undefined ? undefined : required(value.failureCode, "failure_code", 160);
+  return { providerAttemptReference, status: value.status, ...failureCode ? { failureCode } : {} };
+}
+function paymentProviderAdapter(args) {
+  const [provider, contractVersion] = args.key.split(":");
+  const providerApiVersion = required(args.providerApiVersion, "api_version", 100);
+  return Object.freeze({
+    key: args.key,
+    provider,
+    contractVersion,
+    providerApiVersion,
+    async createHostedSetup(input) {
+      assertHostedInput(input);
+      return assertHostedResult(await args.driver.createHostedSetup(input));
     },
-    async placeOrder(request, market) {
-      if (request.type === "futures" && request.leverage) {
-        await signed({
-          type: "futures",
-          path: "/fapi/v1/leverage",
-          method: "POST",
-          params: { symbol: binanceSymbol(request.symbol), leverage: request.leverage }
-        });
-      }
-      const raw = await signed({
-        type: request.type,
-        path: PATHS[request.type].order,
-        method: "POST",
-        weight: 1,
-        params: {
-          symbol: binanceSymbol(request.symbol),
-          side: SIDE[request.side],
-          type: TYPE[request.orderType],
-          quantity: formatAmount(request.quantity, { trim: true }),
-          price: request.price ? formatAmount(request.price, { trim: true }) : undefined,
-          stopPrice: request.stopPrice ? formatAmount(request.stopPrice, { trim: true }) : undefined,
-          timeInForce: request.orderType === "market" ? undefined : (request.timeInForce ?? "gtc").toUpperCase(),
-          newClientOrderId: request.clientOrderId,
-          ...request.type === "margin" ? { sideEffectType: "NO_SIDE_EFFECT" } : {},
-          ...request.dryRun ? { test: "true" } : {}
-        }
-      });
-      return readOrder(raw, market);
+    async completeHostedSetup(input) {
+      assertSetupCompletion(input);
+      return assertCompletionResult(await args.driver.completeHostedSetup(input));
     },
-    async cancelOrder(args) {
-      await signed({
-        type: args.type,
-        path: PATHS[args.type].order,
-        method: "DELETE",
-        params: { symbol: binanceSymbol(args.symbol), orderId: args.venueOrderId }
-      });
+    async createCustomer(input) {
+      required(input.tenantKey, "tenant");
+      required(input.email, "email");
+      required(input.idempotencyKey, "idempotency", 200);
+      return assertCustomerResult(await args.driver.createCustomer(input));
     },
-    async openOrders(args) {
-      const raw = await signed({
-        type: args.type,
-        path: PATHS[args.type].openOrders,
-        method: "GET",
-        weight: args.symbol ? 3 : 40,
-        params: { symbol: args.symbol ? binanceSymbol(args.symbol) : undefined }
-      });
-      return (raw ?? []).map((entry) => readOrder(entry, undefined));
+    async charge(input) {
+      assertChargeInput(input);
+      return assertChargeResult(await args.driver.charge(input));
     },
-    async balances(type) {
-      const raw = await signed({ type, path: PATHS[type].account, method: "GET", weight: 10, params: {} });
-      const rows = raw.balances ?? raw.userAssets ?? (raw.assets ?? []).map((entry) => ({ asset: entry.asset, free: entry.availableBalance }));
-      return rows.filter((entry) => Number(entry.free) > 0).map((entry) => {
-        try {
-          return parseAmount(entry.free, entry.asset);
-        } catch {
-          return null;
-        }
-      }).filter((amount) => amount !== null);
+    async detachPaymentMethod(input) {
+      required(input.tenantKey, "tenant");
+      required(input.providerPaymentMethodReference, "method_reference");
+      required(input.idempotencyKey, "idempotency", 200);
+      return args.driver.detachPaymentMethod(input);
+    },
+    async verifyWebhook(input) {
+      if (!(input.rawBody instanceof Uint8Array) || input.rawBody.byteLength > 1048576) {
+        throw new Error("PAYMENT_WEBHOOK_BODY_INVALID");
+      }
+      return assertWebhookResult(await args.driver.verifyWebhook(input));
+    },
+    async reconcile(input) {
+      required(input.tenantKey, "tenant");
+      required(input.providerAttemptReference, "attempt_reference");
+      return assertReconciliationResult(await args.driver.reconcile(input));
     }
-  };
-}
-function readOrder(raw, market) {
-  const asset = market?.base ?? "BTC";
-  const executed = String(raw.executedQty ?? raw.origQty ?? "0");
-  let filledQuantity;
-  try {
-    filledQuantity = parseAmount(executed, asset);
-  } catch {
-    filledQuantity = zero(asset);
-  }
-  const quoteFilled = Number(raw.cummulativeQuoteQty ?? 0);
-  const filled = Number(executed);
-  return {
-    venueOrderId: String(raw.orderId ?? ""),
-    clientOrderId: raw.clientOrderId ? String(raw.clientOrderId) : undefined,
-    status: toOrderStatus(String(raw.status ?? "NEW")),
-    filledQuantity,
-    ...market && filled > 0 && quoteFilled > 0 ? {
-      averagePrice: (() => {
-        try {
-          return parseAmount((quoteFilled / filled).toFixed(assetSpec(market.quote).decimals), market.quote);
-        } catch {
-          return;
-        }
-      })()
-    } : {},
-    raw
-  };
+  });
 }
-function readBinanceError(error) {
-  const body = error.body;
-  if (!body?.code)
-    return;
-  const known = {
-    [-1013]: ["MIN_NOTIONAL", "The order is below the venue minimum, or off its lot or tick step."],
-    [-2010]: ["MIN_NOTIONAL", "Rejected: insufficient balance, or below the minimum."],
-    [-1111]: ["LOT_STEP", "More decimal places than this market accepts."],
-    [-1121]: ["UNKNOWN_MARKET", "That symbol is not traded on this venue."]
-  };
-  const match = known[body.code];
-  return match ? new VenueError(match[0], `${match[1]} (${body.msg})`) : undefined;
+function definePaymentProvider(args) {
+  const classify = args.classify ?? (() => "retryable");
+  const branch = (invoke) => defineProviderMethodBranches({
+    currentVersion: args.version,
+    versions: { [args.version]: { version: args.version, lifecycle: "current", invoke, classify } }
+  });
+  return defineProvider({
+    id: args.id,
+    label: args.label,
+    multiInstance: true,
+    config: args.config,
+    credentials: args.credentials,
+    methods: {
+      createHostedSetup: branch(args.driver.createHostedSetup),
+      completeHostedSetup: branch(args.driver.completeHostedSetup),
+      createCustomer: branch(args.driver.createCustomer),
+      charge: branch(args.driver.charge),
+      detachPaymentMethod: branch(args.driver.detachPaymentMethod),
+      verifyWebhook: branch(args.driver.verifyWebhook),
+      reconcile: branch(args.driver.reconcile)
+    }
+  });
 }
 export {
-  toOrderStatus,
-  readBinanceError,
-  createBinanceAdapter,
-  binanceSymbol
+  paymentProviderDefinitions,
+  paymentProviderAdapter,
+  definePaymentProvider,
+  billingService,
+  PAYMENT_PROVIDER_KEYS
 };

package/dist/database.js

@@ -336,7 +336,7 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.22";
+var VERSION = "0.1.24";
 
 // src/database.ts
 var pools = new Map;

package/dist/email.js

@@ -336,7 +336,7 @@ function createService(definition, methods, options = {}) {
     }
   };
 }
-var VERSION = "0.1.22";
+var VERSION = "0.1.24";
 
 // src/email.ts
 var recipients = (to) => Array.isArray(to) ? [...to] : [to];