payweave 0.0.0

package/dist/chunk-IUVGM3K7.js

@@ -0,0 +1,765 @@
+import { resolvePlanPricing } from './chunk-535Q3GUN.js';
+import { PayweaveConfigError, redact, PayweaveNetworkError, mapHttpError, PayweaveError, PayweaveAuthError } from './chunk-HTRGMZFH.js';
+import { z } from 'zod';
+
+var PAYSTACK_BASE_URL = "https://api.paystack.co";
+var FLW_V3_BASE_URL = "https://api.flutterwave.com/v3";
+var FLW_V4_BASE_URL = "https://api.flutterwave.cloud/f4bexperience";
+var FLW_V4_SANDBOX_URL = "https://api.flutterwave.cloud/developersandbox";
+var FLW_V4_TOKEN_URL = "https://idp.flutterwave.com/realms/flutterwave/protocol/openid-connect/token";
+var STRIPE_BASE_URL = "https://api.stripe.com";
+var STRIPE_API_VERSION = "2026-06-24.dahlia";
+var commonFields = {
+  timeoutMs: z.number().int().positive().optional(),
+  maxRetries: z.number().int().nonnegative().optional(),
+  baseUrl: z.string().min(1).optional(),
+  fetch: z.custom((v) => typeof v === "function").optional(),
+  environment: z.enum(["test", "live"]).optional(),
+  logger: z.custom((v) => typeof v === "function").optional(),
+  allowInsecureBaseUrl: z.boolean().optional()
+};
+var paystackConfigSchema = z.object({
+  provider: z.literal("paystack"),
+  secretKey: z.string().min(1),
+  ...commonFields
+});
+var flwV3ConfigSchema = z.object({
+  provider: z.literal("flutterwave"),
+  version: z.literal("v3").default("v3"),
+  secretKey: z.string().min(1),
+  encryptionKey: z.string().optional(),
+  webhookSecret: z.string().optional(),
+  ...commonFields
+});
+var flwV4ConfigSchema = z.object({
+  provider: z.literal("flutterwave"),
+  version: z.literal("v4"),
+  clientId: z.string().min(1),
+  clientSecret: z.string().min(1),
+  encryptionKey: z.string().optional(),
+  webhookSecret: z.string().optional(),
+  ...commonFields
+});
+var flutterwaveConfigSchema = z.discriminatedUnion("version", [
+  flwV3ConfigSchema,
+  flwV4ConfigSchema
+]);
+var sdkConfigSchema = z.preprocess((val) => {
+  if (val !== null && typeof val === "object" && !Array.isArray(val) && val.provider === "flutterwave" && !("version" in val)) {
+    return { ...val, version: "v3" };
+  }
+  return val;
+}, z.discriminatedUnion("provider", [paystackConfigSchema, flutterwaveConfigSchema]));
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+function inferEnvironment(provider, secretKey) {
+  if (provider === "paystack") {
+    if (secretKey.startsWith("sk_test_")) return "test";
+    if (secretKey.startsWith("sk_live_")) return "live";
+    throw new PayweaveConfigError(
+      "Unrecognized Paystack secret key \u2014 expected an 'sk_test_' or 'sk_live_' prefix.",
+      { provider }
+    );
+  }
+  if (provider === "stripe") {
+    if (secretKey.startsWith("sk_test_") || secretKey.startsWith("rk_test_")) return "test";
+    if (secretKey.startsWith("sk_live_") || secretKey.startsWith("rk_live_")) return "live";
+    throw new PayweaveConfigError(
+      "Unrecognized Stripe secret key \u2014 expected an 'sk_test_', 'sk_live_', 'rk_test_', or 'rk_live_' prefix.",
+      { provider }
+    );
+  }
+  if (secretKey.startsWith("FLWSECK_TEST-")) return "test";
+  if (secretKey.startsWith("FLWSECK-")) return "live";
+  throw new PayweaveConfigError(
+    "Unrecognized Flutterwave secret key \u2014 expected an 'FLWSECK_TEST-' or 'FLWSECK-' prefix.",
+    { provider }
+  );
+}
+function toConfigError(err) {
+  if (err instanceof z.ZodError) {
+    const detail = err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    return new PayweaveConfigError(`Invalid Payweave config \u2014 ${detail}`);
+  }
+  if (err instanceof PayweaveConfigError) return err;
+  return new PayweaveConfigError(
+    `Invalid Payweave config \u2014 ${err instanceof Error ? err.message : String(err)}`
+  );
+}
+function guardBaseUrl(baseUrl, allowInsecure, logger, provider) {
+  if (/^https:\/\//i.test(baseUrl)) return;
+  if (!allowInsecure) {
+    throw new PayweaveConfigError(
+      `Refusing non-HTTPS baseUrl "${baseUrl}". Set allowInsecureBaseUrl: true to override (testing only).`,
+      { provider }
+    );
+  }
+  logger?.({
+    type: "warn",
+    message: `\u26A0\uFE0F  INSECURE baseUrl "${baseUrl}" \u2014 credentials will be sent unencrypted. Never do this in production.`
+  });
+}
+function resolveConfig(input) {
+  let parsed;
+  try {
+    parsed = sdkConfigSchema.parse(input);
+  } catch (err) {
+    throw toConfigError(err);
+  }
+  const timeoutMs = parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxRetries = parsed.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const allowInsecureBaseUrl = parsed.allowInsecureBaseUrl ?? false;
+  const logger = parsed.logger;
+  if (parsed.provider === "paystack") {
+    const environment2 = resolveKeyedEnvironment("paystack", parsed.secretKey, parsed.environment);
+    const baseUrl2 = parsed.baseUrl ?? PAYSTACK_BASE_URL;
+    guardBaseUrl(baseUrl2, allowInsecureBaseUrl, logger, "paystack");
+    return {
+      provider: "paystack",
+      version: void 0,
+      environment: environment2,
+      baseUrl: baseUrl2,
+      secretKey: parsed.secretKey,
+      clientId: void 0,
+      clientSecret: void 0,
+      encryptionKey: void 0,
+      webhookSecret: void 0,
+      timeoutMs,
+      maxRetries,
+      fetch: parsed.fetch,
+      logger,
+      allowInsecureBaseUrl,
+      tokenUrl: void 0
+    };
+  }
+  if (parsed.version === "v4") {
+    const environment2 = parsed.environment ?? "test";
+    const baseUrl2 = parsed.baseUrl ?? (environment2 === "test" ? FLW_V4_SANDBOX_URL : FLW_V4_BASE_URL);
+    guardBaseUrl(baseUrl2, allowInsecureBaseUrl, logger, "flutterwave");
+    return {
+      provider: "flutterwave",
+      version: "v4",
+      environment: environment2,
+      baseUrl: baseUrl2,
+      secretKey: void 0,
+      clientId: parsed.clientId,
+      clientSecret: parsed.clientSecret,
+      encryptionKey: parsed.encryptionKey,
+      webhookSecret: parsed.webhookSecret,
+      timeoutMs,
+      maxRetries,
+      fetch: parsed.fetch,
+      logger,
+      allowInsecureBaseUrl,
+      tokenUrl: FLW_V4_TOKEN_URL
+    };
+  }
+  const environment = resolveKeyedEnvironment("flutterwave", parsed.secretKey, parsed.environment);
+  const baseUrl = parsed.baseUrl ?? FLW_V3_BASE_URL;
+  guardBaseUrl(baseUrl, allowInsecureBaseUrl, logger, "flutterwave");
+  return {
+    provider: "flutterwave",
+    version: "v3",
+    environment,
+    baseUrl,
+    secretKey: parsed.secretKey,
+    clientId: void 0,
+    clientSecret: void 0,
+    encryptionKey: parsed.encryptionKey,
+    webhookSecret: parsed.webhookSecret,
+    timeoutMs,
+    maxRetries,
+    fetch: parsed.fetch,
+    logger,
+    allowInsecureBaseUrl,
+    tokenUrl: void 0
+  };
+}
+function resolveKeyedEnvironment(provider, secretKey, explicit) {
+  const inferred = inferEnvironment(provider, secretKey);
+  if (explicit && explicit !== inferred) {
+    throw new PayweaveConfigError(
+      `environment "${explicit}" conflicts with the ${provider} key prefix (which indicates "${inferred}"). Remove the explicit environment or use a matching key.`,
+      { provider }
+    );
+  }
+  return inferred;
+}
+var PAYWEAVE_PROVIDER_KEYS = ["stripe", "paystack", "flutterwave"];
+var providerKeySchema = z.enum(PAYWEAVE_PROVIDER_KEYS);
+var stripeProviderConfigSchema = z.object({
+  secretKey: z.string().min(1),
+  /** `whsec_*` — REQUIRED before any `webhooks.*` call (fail closed); optional here. */
+  webhookSecret: z.string().optional(),
+  /** Pins the `Stripe-Version` header; defaults to {@link STRIPE_API_VERSION}. */
+  apiVersion: z.string().optional(),
+  /**
+   * Connect platforms only — a connected account id (`acct_*`) sent as the
+   * `Stripe-Account` header on every request so calls act on that account
+   * (https://docs.stripe.com/connect/authentication — verified 2026-07-12).
+   */
+  accountId: z.string().min(1).optional(),
+  ...commonFields
+});
+var paystackProviderConfigSchema = paystackConfigSchema.omit({ provider: true });
+var flutterwaveProviderConfigSchema = z.preprocess((val) => {
+  if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+    const withDefaults = { ...val };
+    if (!("version" in withDefaults)) withDefaults.version = "v3";
+    withDefaults.provider = "flutterwave";
+    return withDefaults;
+  }
+  return val;
+}, flutterwaveConfigSchema);
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var storeHasMethod = (store, method) => isPlainObject(store) && typeof store[method] === "function";
+var isDatabaseAdapter = (v) => isPlainObject(v) && typeof v.dialect === "string" && typeof v.transaction === "function" && storeHasMethod(v.customers, "upsert") && storeHasMethod(v.plans, "pushVersion") && storeHasMethod(v.subscriptions, "getActive") && storeHasMethod(v.balances, "consume") && storeHasMethod(v.webhookEvents, "claim") && storeHasMethod(v.migrations, "apply");
+var databaseAdapterSchema = z.custom(
+  isDatabaseAdapter,
+  "expected a payweave/db/* database adapter object"
+);
+var isPlan = (v) => isPlainObject(v) && typeof v.id === "string" && typeof v.default === "boolean" && Array.isArray(v.includes);
+var planSchema = z.custom(
+  isPlan,
+  "expected a plan() definition (see plans-and-features.md)"
+);
+var payweaveConfigSchema = z.strictObject({
+  // ── Providers (at least one — rule 2, enforced in the resolver) ──
+  stripe: stripeProviderConfigSchema.optional(),
+  paystack: paystackProviderConfigSchema.optional(),
+  flutterwave: flutterwaveProviderConfigSchema.optional(),
+  /** Routing target for unified/billing calls — must name a configured key (rule 3). */
+  defaultProvider: providerKeySchema.optional(),
+  // ── Billing platform (billing surface activates when present) ──
+  database: databaseAdapterSchema.optional(),
+  products: z.array(planSchema).optional(),
+  /** ISO 4217 — used by plan prices without an explicit currency. */
+  defaultCurrency: z.string().min(1).optional(),
+  // ── Common transport options (shared across providers) ──
+  timeoutMs: commonFields.timeoutMs,
+  maxRetries: commonFields.maxRetries,
+  fetch: commonFields.fetch,
+  logger: commonFields.logger,
+  /** Explicit env — per-provider key inference still applies; conflicts throw (rule 4). */
+  environment: commonFields.environment
+});
+var AT_LEAST_ONE_PROVIDER = "configure at least one provider \u2014 e.g. createPayweave({ stripe: { secretKey } })";
+function compact(obj) {
+  const out = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+function rootTransport(parsed) {
+  return compact({
+    timeoutMs: parsed.timeoutMs,
+    maxRetries: parsed.maxRetries,
+    fetch: parsed.fetch,
+    logger: parsed.logger,
+    environment: parsed.environment
+  });
+}
+function resolveStripeEntry(sub, parsed) {
+  const logger = sub.logger ?? parsed.logger;
+  const allowInsecureBaseUrl = sub.allowInsecureBaseUrl ?? false;
+  const environment = resolveKeyedEnvironment(
+    "stripe",
+    sub.secretKey,
+    sub.environment ?? parsed.environment
+  );
+  const baseUrl = sub.baseUrl ?? STRIPE_BASE_URL;
+  guardBaseUrl(baseUrl, allowInsecureBaseUrl, logger, "stripe");
+  return {
+    provider: "stripe",
+    version: void 0,
+    environment,
+    baseUrl,
+    secretKey: sub.secretKey,
+    clientId: void 0,
+    clientSecret: void 0,
+    encryptionKey: void 0,
+    webhookSecret: sub.webhookSecret,
+    timeoutMs: sub.timeoutMs ?? parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: sub.maxRetries ?? parsed.maxRetries ?? DEFAULT_MAX_RETRIES,
+    fetch: sub.fetch ?? parsed.fetch,
+    logger,
+    allowInsecureBaseUrl,
+    tokenUrl: void 0,
+    apiVersion: sub.apiVersion,
+    accountId: sub.accountId
+  };
+}
+function resolveLegacyEntry(key, sub, parsed) {
+  const merged = { ...rootTransport(parsed), ...compact({ ...sub }), provider: key };
+  return { ...resolveConfig(merged), apiVersion: void 0 };
+}
+function assertUniquePlanIds(products) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of products) {
+    if (seen.has(p.id)) {
+      throw new PayweaveConfigError(
+        `duplicate plan id "${p.id}" \u2014 plan ids must be unique across products.`
+      );
+    }
+    seen.add(p.id);
+  }
+}
+function assertOneDefaultPerGroup(products) {
+  const defaultPlanIdByGroup = /* @__PURE__ */ new Map();
+  for (const p of products) {
+    if (!p.default || p.group === void 0) continue;
+    const existing = defaultPlanIdByGroup.get(p.group);
+    if (existing !== void 0) {
+      throw new PayweaveConfigError(
+        `group "${p.group}" has more than one default plan ("${existing}" and "${p.id}") \u2014 only one plan per group can be default: true.`
+      );
+    }
+    defaultPlanIdByGroup.set(p.group, p.id);
+  }
+}
+function assertNoConflictingFeatureTypes(products) {
+  const typeByFeatureId = /* @__PURE__ */ new Map();
+  for (const p of products) {
+    for (const inclusion of p.includes) {
+      const existing = typeByFeatureId.get(inclusion.featureId);
+      if (existing === void 0) {
+        typeByFeatureId.set(inclusion.featureId, { type: inclusion.type, planId: p.id });
+        continue;
+      }
+      if (existing.type !== inclusion.type) {
+        throw new PayweaveConfigError(
+          `feature "${inclusion.featureId}" is used as both "${existing.type}" (plan "${existing.planId}") and "${inclusion.type}" (plan "${p.id}") \u2014 a feature must have the same type everywhere.`
+        );
+      }
+    }
+  }
+}
+function resolveProducts(products, defaultCurrency) {
+  if (products === void 0) return void 0;
+  assertUniquePlanIds(products);
+  assertOneDefaultPerGroup(products);
+  assertNoConflictingFeatureTypes(products);
+  return products.map((p) => {
+    if (p.price === void 0) {
+      return { ...p, price: void 0 };
+    }
+    const currency = p.price.currency ?? defaultCurrency;
+    if (currency === void 0) {
+      throw new PayweaveConfigError(
+        `plan "${p.id}": price has no currency \u2014 set price.currency or configure defaultCurrency.`
+      );
+    }
+    return { ...p, price: resolvePlanPricing(p, currency) };
+  });
+}
+function resolvePayweaveConfig(input) {
+  let parsed;
+  try {
+    parsed = payweaveConfigSchema.parse(input);
+  } catch (err) {
+    throw toConfigError(err);
+  }
+  const providers = PAYWEAVE_PROVIDER_KEYS.filter((key) => parsed[key] !== void 0);
+  const [firstProvider] = providers;
+  if (firstProvider === void 0) {
+    throw new PayweaveConfigError(AT_LEAST_ONE_PROVIDER);
+  }
+  let defaultProvider;
+  if (parsed.defaultProvider !== void 0) {
+    if (!providers.includes(parsed.defaultProvider)) {
+      throw new PayweaveConfigError(
+        `defaultProvider "${parsed.defaultProvider}" is not a configured provider \u2014 configured: ${providers.join(", ")}.`
+      );
+    }
+    defaultProvider = parsed.defaultProvider;
+  } else if (providers.length === 1) {
+    defaultProvider = firstProvider;
+  } else {
+    throw new PayweaveConfigError(
+      `multiple providers configured (${providers.join(", ")}) \u2014 set defaultProvider to one of them.`
+    );
+  }
+  const providerConfigs = {};
+  const environments = [];
+  if (parsed.stripe !== void 0) {
+    const entry = resolveStripeEntry(parsed.stripe, parsed);
+    providerConfigs.stripe = entry;
+    environments.push(["stripe", entry.environment]);
+  }
+  if (parsed.paystack !== void 0) {
+    const entry = resolveLegacyEntry("paystack", parsed.paystack, parsed);
+    providerConfigs.paystack = entry;
+    environments.push(["paystack", entry.environment]);
+  }
+  if (parsed.flutterwave !== void 0) {
+    const entry = resolveLegacyEntry("flutterwave", parsed.flutterwave, parsed);
+    providerConfigs.flutterwave = entry;
+    environments.push(["flutterwave", entry.environment]);
+  }
+  if (parsed.environment !== void 0) {
+    for (const [key, env] of environments) {
+      if (env !== parsed.environment) {
+        throw new PayweaveConfigError(
+          `environment "${parsed.environment}" conflicts with the ${key} provider's resolved environment "${env}". Remove the explicit environment or align the ${key} config.`,
+          { provider: key }
+        );
+      }
+    }
+  }
+  const distinctEnvs = new Set(environments.map(([, env]) => env));
+  if (distinctEnvs.size > 1) {
+    const detail = environments.map(([key, env]) => `${key} is "${env}"`).join(", ");
+    throw new PayweaveConfigError(
+      `mixed environments across providers \u2014 ${detail}. One Payweave client must be all-test or all-live; use separate clients to mix.`
+    );
+  }
+  const firstEnvironment = environments[0];
+  if (firstEnvironment === void 0) {
+    throw new PayweaveConfigError(AT_LEAST_ONE_PROVIDER);
+  }
+  if (parsed.products !== void 0 && parsed.database === void 0) {
+    throw new PayweaveConfigError("plans need a database \u2014 pass a payweave/db/* adapter");
+  }
+  const products = resolveProducts(parsed.products, parsed.defaultCurrency);
+  return {
+    providers,
+    defaultProvider,
+    environment: firstEnvironment[1],
+    providerConfigs,
+    database: parsed.database,
+    products,
+    defaultCurrency: parsed.defaultCurrency,
+    timeoutMs: parsed.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    maxRetries: parsed.maxRetries ?? DEFAULT_MAX_RETRIES,
+    fetch: parsed.fetch,
+    logger: parsed.logger
+  };
+}
+
+// src/core/retry.ts
+var DEFAULT_RETRY_POLICY = {
+  maxRetries: 2,
+  baseMs: 250,
+  capMs: 8e3
+};
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+var RETRY_AFTER_CAP_MS = 3e4;
+function isRetryableStatus(status) {
+  return RETRYABLE_STATUSES.has(status);
+}
+function isRetryableRequest(method, idempotencyKey) {
+  return method.toUpperCase() === "GET" || idempotencyKey != null;
+}
+function backoffDelay(attempt, policy = DEFAULT_RETRY_POLICY, rng = Math.random) {
+  const ceiling = Math.min(policy.capMs, policy.baseMs * 2 ** attempt);
+  return Math.floor(rng() * ceiling);
+}
+function parseRetryAfter(headerValue, now = Date.now()) {
+  if (headerValue == null) return null;
+  const trimmed = headerValue.trim();
+  if (trimmed === "") return null;
+  if (/^\d+$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    return Math.min(seconds * 1e3, RETRY_AFTER_CAP_MS);
+  }
+  const when = Date.parse(trimmed);
+  if (!Number.isNaN(when)) {
+    return Math.min(Math.max(0, when - now), RETRY_AFTER_CAP_MS);
+  }
+  return null;
+}
+
+// src/core/version.ts
+var SDK_VERSION = "0.0.0";
+
+// src/core/http.ts
+function jsonBodyEncoder(body) {
+  return { contentType: "application/json", body: JSON.stringify(body) };
+}
+function bearer(secretKey) {
+  return {
+    async applyAuth(init) {
+      init.headers.set("Authorization", `Bearer ${secretKey}`);
+    }
+  };
+}
+function oauthClientCredentials(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  let token = null;
+  let refreshAtMs = 0;
+  let inflight = null;
+  async function fetchToken() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: opts.clientId,
+      client_secret: opts.clientSecret
+    });
+    let res;
+    try {
+      res = await doFetch(opts.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: "application/json"
+        },
+        body: body.toString()
+      });
+    } catch (err) {
+      throw new PayweaveNetworkError("Failed to reach the Flutterwave v4 token endpoint.", {
+        provider: "flutterwave",
+        cause: err
+      });
+    }
+    if (!res.ok) {
+      throw new PayweaveAuthError(
+        `Flutterwave v4 token request failed (${res.status}).`,
+        { provider: "flutterwave", httpStatus: res.status }
+      );
+    }
+    const json = await res.json();
+    if (typeof json.access_token !== "string") {
+      throw new PayweaveAuthError("Flutterwave v4 token response had no access_token.", {
+        provider: "flutterwave"
+      });
+    }
+    const ttlSeconds = typeof json.expires_in === "number" ? json.expires_in : 600;
+    refreshAtMs = Date.now() + ttlSeconds * 1e3 * 0.8;
+    token = json.access_token;
+    return token;
+  }
+  async function getToken(force) {
+    if (!force && token !== null && Date.now() < refreshAtMs) return token;
+    if (inflight) return inflight;
+    inflight = fetchToken().finally(() => {
+      inflight = null;
+    });
+    return inflight;
+  }
+  return {
+    async applyAuth(init) {
+      const t = await getToken(false);
+      init.headers.set("Authorization", `Bearer ${t}`);
+    },
+    async refresh() {
+      await getToken(true);
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+var HttpClient = class {
+  baseUrl;
+  auth;
+  provider;
+  timeoutMs;
+  policy;
+  doFetch;
+  logger;
+  userAgent;
+  encodeBody;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.auth = options.auth;
+    this.provider = options.provider;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.policy = {
+      ...DEFAULT_RETRY_POLICY,
+      maxRetries: options.maxRetries ?? DEFAULT_RETRY_POLICY.maxRetries
+    };
+    this.doFetch = options.fetch ?? fetch;
+    this.logger = options.logger;
+    this.userAgent = options.userAgent ?? `payweave/${SDK_VERSION} (${options.provider})`;
+    this.encodeBody = options.bodyEncoder ?? jsonBodyEncoder;
+  }
+  buildUrl(path, query) {
+    const rel = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(this.baseUrl + rel);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0 || value === null) continue;
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  log(event) {
+    this.logger?.(event);
+  }
+  /**
+   * Execute a request with auth, timeout, retry, and error mapping. On 2xx,
+   * JSON-parses and (if `schema` given) `safeParse`s — drift is logged and the
+   * raw JSON returned, never thrown.
+   */
+  async request(opts) {
+    const method = opts.method.toUpperCase();
+    const url = this.buildUrl(opts.path, opts.query);
+    const eligible = isRetryableRequest(method, opts.idempotencyKey);
+    const encoded = opts.body !== void 0 ? this.encodeBody(opts.body) : void 0;
+    let attempt = 0;
+    let did401Refresh = false;
+    for (; ; ) {
+      const headers = new Headers();
+      headers.set("Accept", "application/json");
+      headers.set("User-Agent", this.userAgent);
+      if (encoded !== void 0) headers.set("Content-Type", encoded.contentType);
+      if (opts.idempotencyKey) headers.set("Idempotency-Key", opts.idempotencyKey);
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? this.timeoutMs);
+      let res;
+      try {
+        await this.auth.applyAuth({ headers });
+        this.log({
+          type: "request",
+          provider: this.provider,
+          method,
+          url,
+          attempt,
+          headers: redact(headers),
+          body: redact(opts.body)
+        });
+        res = await this.doFetch(url, {
+          method,
+          headers,
+          ...encoded !== void 0 ? { body: encoded.body } : {},
+          signal
+        });
+      } catch (err2) {
+        const known = err2 instanceof PayweaveError;
+        const finalErr = known ? err2 : new PayweaveNetworkError(
+          isAbortError(err2) ? `Request to ${this.provider} timed out after ${opts.timeoutMs ?? this.timeoutMs}ms.` : `Network error contacting ${this.provider}.`,
+          { provider: this.provider, cause: err2 }
+        );
+        if (eligible && finalErr.isRetryable && attempt < this.policy.maxRetries) {
+          const delay = backoffDelay(attempt, this.policy);
+          this.log({
+            type: "retry",
+            provider: this.provider,
+            attempt,
+            reason: known ? "auth" : "network",
+            delay
+          });
+          await sleep(delay);
+          attempt += 1;
+          continue;
+        }
+        this.log({ type: "error", provider: this.provider, error: finalErr.toJSON() });
+        throw finalErr;
+      }
+      if (res.ok) {
+        const json = await this.readJson(res);
+        this.log({
+          type: "response",
+          provider: this.provider,
+          status: res.status,
+          body: redact(json)
+        });
+        if (opts.schema) {
+          const parsed = opts.schema.safeParse(json);
+          if (!parsed.success) {
+            this.log({
+              type: "schema_drift",
+              provider: this.provider,
+              path: opts.path,
+              issues: parsed.error.issues.map((i) => ({
+                path: i.path.join("."),
+                message: i.message
+              }))
+            });
+            return json;
+          }
+          return parsed.data;
+        }
+        return json;
+      }
+      const errorBody = await this.readJson(res);
+      const retryAfterMs = parseRetryAfter(res.headers.get("retry-after"));
+      const requestId = res.headers.get("x-request-id") ?? res.headers.get("x-requestid") ?? res.headers.get("request-id") ?? void 0;
+      if (res.status === 401 && this.auth.refresh && !did401Refresh) {
+        did401Refresh = true;
+        this.log({ type: "retry", provider: this.provider, attempt, reason: "401-refresh" });
+        await this.auth.refresh();
+        continue;
+      }
+      if (isRetryableStatus(res.status) && eligible && attempt < this.policy.maxRetries) {
+        const delay = retryAfterMs ?? backoffDelay(attempt, this.policy);
+        this.log({
+          type: "retry",
+          provider: this.provider,
+          attempt,
+          reason: `status-${res.status}`,
+          delay
+        });
+        await sleep(delay);
+        attempt += 1;
+        continue;
+      }
+      const err = mapHttpError(this.provider, res.status, errorBody, {
+        ...retryAfterMs !== null ? { retryAfterMs } : {},
+        ...requestId !== void 0 ? { requestId } : {}
+      });
+      this.log({ type: "error", provider: this.provider, error: err.toJSON() });
+      throw err;
+    }
+  }
+  async readJson(res) {
+    const text = await res.text();
+    if (text === "") return void 0;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+function readHeader(headers, name) {
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name) ?? void 0;
+  }
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lower) {
+      return Array.isArray(value) ? value[0] : value;
+    }
+  }
+  return void 0;
+}
+var isFn = (v) => typeof v === "function";
+var fnSchema = z.custom(isFn, {
+  message: "expected a function"
+});
+var envSpecSchema = z.object({ baseUrl: z.string().min(1) });
+var zodSchemaSchema = z.custom((v) => v instanceof z.ZodType, {
+  message: "expected a zod schema"
+});
+var providerAdapterSchema = z.object({
+  id: z.string().min(1),
+  configKey: z.string().min(1),
+  configSchema: zodSchemaSchema,
+  environments: z.object({ test: envSpecSchema, live: envSpecSchema }),
+  inferEnvironment: fnSchema,
+  createHttp: fnSchema,
+  webhooks: z.object({
+    signatureHeader: z.string().min(1),
+    verify: fnSchema,
+    parse: fnSchema,
+    toUnified: fnSchema
+  }),
+  unified: z.record(z.string(), z.unknown()).optional(),
+  billing: z.record(z.string(), z.unknown()).optional()
+});
+function defineProvider(adapter) {
+  const result = providerAdapterSchema.safeParse(adapter);
+  if (!result.success) {
+    const detail = result.error.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+    throw new PayweaveConfigError(`Invalid provider adapter \u2014 ${detail}`);
+  }
+  return adapter;
+}
+
+export { DEFAULT_MAX_RETRIES, DEFAULT_RETRY_POLICY, DEFAULT_TIMEOUT_MS, FLW_V3_BASE_URL, FLW_V4_BASE_URL, FLW_V4_SANDBOX_URL, FLW_V4_TOKEN_URL, HttpClient, PAYSTACK_BASE_URL, PAYWEAVE_PROVIDER_KEYS, RETRYABLE_STATUSES, RETRY_AFTER_CAP_MS, SDK_VERSION, STRIPE_API_VERSION, STRIPE_BASE_URL, backoffDelay, bearer, defineProvider, flutterwaveProviderConfigSchema, inferEnvironment, isRetryableRequest, isRetryableStatus, oauthClientCredentials, parseRetryAfter, paystackProviderConfigSchema, payweaveConfigSchema, readHeader, resolveConfig, resolvePayweaveConfig, sdkConfigSchema, stripeProviderConfigSchema };
+//# sourceMappingURL=chunk-IUVGM3K7.js.map
+//# sourceMappingURL=chunk-IUVGM3K7.js.map