@capxul/sdk 0.2.0-alpha.4 → 0.2.0-alpha.5

package/dist/index.js

@@ -1,4234 +0,0 @@
-import { componentsGeneric, anyApi } from 'convex/server';
-import { toSafeSmartAccount } from 'permissionless/accounts';
-import { getAddress, encodeFunctionData, encodePacked, keccak256, getContractAddress, parseUnits, createPublicClient, http } from 'viem';
-import { entryPoint07Address, createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
-import { baseSepolia } from 'viem/chains';
-import { ConvexHttpClient } from 'convex/browser';
-import { setup, fromPromise, assign } from 'xstate';
-import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
-
-// src/_generated/api.js
-var api = anyApi;
-componentsGeneric();
-
-// src/errors.ts
-var CapxulError = class extends Error {
-  code;
-  details;
-  operationId;
-  correlationId;
-  retryable;
-  constructor(init) {
-    super(
-      init.message,
-      init.cause !== void 0 ? { cause: init.cause } : void 0
-    );
-    this.name = "CapxulError";
-    this.code = init.code;
-    this.details = init.details;
-    this.operationId = init.operationId;
-    this.correlationId = init.correlationId;
-    this.retryable = init.retryable;
-  }
-};
-function notImplemented(method) {
-  return new CapxulError({
-    code: "NOT_IMPLEMENTED",
-    message: `${method} is not yet implemented in @capxul/sdk (Slice C scaffold).`
-  });
-}
-function stub(method) {
-  return [notImplemented(method), null];
-}
-
-// src/internal/convex-error.ts
-function isConvexClientError(error) {
-  if (typeof error !== "object" || error === null || !("data" in error)) {
-    return false;
-  }
-  const data = error.data;
-  return typeof data === "object" && data !== null;
-}
-function fromConvexError(error) {
-  if (error instanceof CapxulError) {
-    return error;
-  }
-  if (isConvexClientError(error)) {
-    return new CapxulError({
-      code: error.data.code ?? "UNKNOWN",
-      message: error.data.message ?? error.message,
-      details: error.data.details,
-      correlationId: error.data.correlationId,
-      cause: error
-    });
-  }
-  return new CapxulError({
-    code: "UNKNOWN",
-    message: error instanceof Error ? error.message : String(error),
-    cause: error
-  });
-}
-
-// ../observability/src/try-catch.ts
-async function tryCatch(promise) {
-  try {
-    return [null, await promise];
-  } catch (e) {
-    return [e instanceof Error ? e : new Error(String(e)), null];
-  }
-}
-
-// ../observability/src/debug-log.ts
-function isDevelopmentBuild() {
-  if (typeof process === "undefined") {
-    return false;
-  }
-  return process.env?.NODE_ENV === "development" || process.env?.NODE_ENV === "test";
-}
-function debugLog(line) {
-  if (!isDevelopmentBuild()) return;
-  if (typeof globalThis !== "undefined" && "window" in globalThis && typeof console?.info === "function") {
-    console.info(line);
-    return;
-  }
-  if (typeof process !== "undefined" && typeof process.stderr?.write === "function") {
-    process.stderr.write(`${line}
-`);
-  }
-}
-function formatDebugValue(value) {
-  if (value === void 0 || value === "") return "";
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-function track(...args) {
-  const [name, props] = args;
-  debugLog(`[TRACK] ${name} ${formatDebugValue(props ?? "")}`);
-}
-
-// ../config/src/chain.ts
-var CAPXUL_PAYMENTS_ADDRESS = "0xe740ea65521edc9bef0ea75d30b5334711db99f4";
-var TEST_USDC_ADDRESS = "0xf09fcbb6df9f8f918e58f9c8ab15a76ade862b77";
-var CAPXUL_API_BASE_URL = "https://elated-oyster-269.convex.site";
-
-// ../config/src/timing.ts
-var FLOW_INVOKE_TIMEOUT_MS = 3e4;
-var WEBHOOK_FRESHNESS_WINDOW_MS = 5 * 60 * 1e3;
-
-// ../config/src/errors.ts
-var CapxulError2 = class extends Error {
-  code;
-  details;
-  correlationId;
-  layer;
-  constructor(code, message, options) {
-    super(message, options?.cause ? { cause: options.cause } : void 0);
-    this.code = code;
-    this.details = options?.details;
-    this.correlationId = options?.correlationId;
-    this.layer = options?.layer;
-  }
-};
-var Errors = {
-  notAuthenticated: () => new CapxulError2("NOT_AUTHENTICATED", "Not authenticated"),
-  profileNotFound: (authUserId) => new CapxulError2("PROFILE_NOT_FOUND", `Profile not found for user ${authUserId}`),
-  smartAccountMissing: (authUserId) => new CapxulError2("SMART_ACCOUNT_MISSING", `Smart account not provisioned for user ${authUserId}`),
-  envMissing: (name) => new CapxulError2("ENV_MISSING", `Environment variable ${name} not configured`),
-  openfortApi: (operation, cause) => new CapxulError2(
-    "PROVIDER_ERROR",
-    `Openfort ${operation} failed: ${cause instanceof Error ? cause.message : String(cause)}`,
-    { cause, details: { provider: "openfort", operation } }
-  ),
-  shieldApi: (status, detail) => new CapxulError2(
-    "PROVIDER_ERROR",
-    `Shield API error (${status}): ${detail}`,
-    { details: { provider: "shield", status } }
-  ),
-  providerError: (provider, operation, cause) => (
-    // Public `message` is redacted to a fixed shape so provider-side
-    // exception text never leaks to the client. The original `cause`
-    // is preserved on `Error.cause` for server-side debugging via
-    // observability sinks (Sentry, console traces).
-    new CapxulError2(
-      "PROVIDER_ERROR",
-      `Provider error: ${provider} ${operation}`,
-      { cause, details: { provider, operation } }
-    )
-  ),
-  invalidInput: (field, reason) => new CapxulError2(
-    "INVALID_INPUT",
-    `Invalid ${field}: ${reason}`,
-    { details: { field, reason } }
-  ),
-  playerNotFound: (playerId) => new CapxulError2(
-    "PLAYER_NOT_FOUND",
-    playerId ? `Openfort player ${playerId} not found` : "Openfort player not found"
-  ),
-  accountNotFound: (accountId) => new CapxulError2(
-    "ACCOUNT_NOT_FOUND",
-    accountId ? `Openfort account ${accountId} not found` : "Openfort smart account not found"
-  ),
-  invalidRecipient: (reason) => new CapxulError2("INVALID_RECIPIENT", reason),
-  permissionDenied: (reason = "Permission denied") => new CapxulError2("PERMISSION_DENIED", reason),
-  notFound: (resource, id) => new CapxulError2(
-    "NOT_FOUND",
-    id ? `${resource} ${id} not found` : `${resource} not found`
-  ),
-  idempotencyConflict: (details) => new CapxulError2(
-    "IDEMPOTENCY_CONFLICT",
-    "Idempotency key was already used for a different request",
-    { details }
-  ),
-  emailDeliveryFailed: (detail, details) => new CapxulError2("EMAIL_DELIVERY_FAILED", `Failed to send email: ${detail}`, {
-    details
-  }),
-  rateLimited: (details) => new CapxulError2("RATE_LIMITED", "Request was rate limited", {
-    details: { ...details }
-  }),
-  internalError: (reason) => new CapxulError2("INTERNAL_ERROR", `Internal error: ${reason}`),
-  /**
-   * Verification gate. Surfaced when a request hits a verification
-   * boundary the actor cannot cross under their current state. Two
-   * variants share this code:
-   *
-   * - Rail gate (Withdrawals v1 W2, #465): the resolved
-   *   `external_account.kind` routes to a withdrawal rail (e.g.
-   *   `fiat_offramp`, `card_payout`) that is not yet supported. Carries
-   *   `details.rail` + `details.currentKind`.
-   * - KYC tier gate (legacy / future): the actor's KYC tier is below
-   *   the required tier. Carries `details.requiredTier`.
-   *
-   * Code is shared because both expose the same UX shape ("you cannot
-   * proceed until verification advances"); the `details.*` keys
-   * differentiate the route.
-   */
-  verificationRequired: (details) => {
-    const message = "rail" in details ? `Withdrawal rail "${details.rail}" (kind=${details.currentKind}) is not yet supported.` : `Verification tier ${details.requiredTier} is required.`;
-    return new CapxulError2("VERIFICATION_REQUIRED", message, {
-      details: { ...details }
-    });
-  }
-};
-
-// ../config/src/safe.ts
-var SAFE_PROXY_FACTORY = "0x4e1dcf7ad4e460cfd30791ccc4f9c8a4f820ec67";
-var SAFE_L2_SINGLETON = "0x29fcb43b46531bca003ddc8fcb67ffe91900c762";
-var SAFE_MODULE_SETUP = "0x2dd68b007b46fbe91b9a7c3eda5a7a1063cb5b47";
-var SAFE_4337_MODULE = "0x75cf11467937ce3f2f357ce24ffc3dbf8fd5c226";
-var MULTI_SEND = "0x38869bf66a61cf6bdb996a6ae40d5853fd43b526";
-
-// ../config/src/org-roles.ts
-function roleKeyFromLabel(label) {
-  const bytes = new TextEncoder().encode(label);
-  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-  return "0x" + hex.padEnd(64, "0");
-}
-roleKeyFromLabel("OWNER");
-roleKeyFromLabel("FINANCE_MANAGER");
-roleKeyFromLabel("PAYMENTS_OPERATOR");
-var defaultSafeDeriveConfig = {
-  safeProxyFactory: SAFE_PROXY_FACTORY,
-  safeL2Singleton: SAFE_L2_SINGLETON,
-  safeModuleSetup: SAFE_MODULE_SETUP,
-  safe4337Module: SAFE_4337_MODULE,
-  multiSend: MULTI_SEND
-};
-var SAFE_PROXY_CREATION_CODE = "0x608060405234801561001057600080fd5b506040516101e63803806101e68339818101604052602081101561003357600080fd5b8101908080519060200190929190505050600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614156100ca576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806101c46022913960400191505060405180910390fd5b806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505060ab806101196000396000f3fe608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea264697066735822122003d1488ee65e08fa41e58e888a9865554c535f2c77126a82cb4c0f917f31441364736f6c63430007060033496e76616c69642073696e676c65746f6e20616464726573732070726f7669646564";
-var enableModulesAbi = [
-  {
-    type: "function",
-    name: "enableModules",
-    inputs: [{ type: "address[]", name: "modules" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  }
-];
-var multiSendAbi = [
-  {
-    type: "function",
-    name: "multiSend",
-    inputs: [{ type: "bytes", name: "transactions" }],
-    outputs: [],
-    stateMutability: "payable"
-  }
-];
-var setupAbi = [
-  {
-    type: "function",
-    name: "setup",
-    inputs: [
-      { type: "address[]", name: "owners" },
-      { type: "uint256", name: "threshold" },
-      { type: "address", name: "to" },
-      { type: "bytes", name: "data" },
-      { type: "address", name: "fallbackHandler" },
-      { type: "address", name: "paymentToken" },
-      { type: "uint256", name: "payment" },
-      { type: "address", name: "paymentReceiver" }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
-  }
-];
-function encodeInternalTransaction(tx) {
-  const encoded = encodePacked(
-    ["uint8", "address", "uint256", "uint256", "bytes"],
-    [
-      tx.operation,
-      tx.to,
-      tx.value,
-      BigInt(tx.data.slice(2).length / 2),
-      tx.data
-    ]
-  );
-  return encoded.slice(2);
-}
-function computeSaltNonce(ownerAddress) {
-  return BigInt(`0x${ownerAddress.toLowerCase().slice(2).padEnd(64, "0")}`);
-}
-function deriveSafeAddress(signerAddress, config = defaultSafeDeriveConfig) {
-  const saltNonce = computeSaltNonce(signerAddress);
-  const enableModulesData = encodeFunctionData({
-    abi: enableModulesAbi,
-    functionName: "enableModules",
-    args: [[config.safe4337Module]]
-  });
-  const innerTx = encodeInternalTransaction({
-    operation: 1,
-    to: config.safeModuleSetup,
-    value: 0n,
-    data: enableModulesData
-  });
-  const multiSendCallData = encodeFunctionData({
-    abi: multiSendAbi,
-    functionName: "multiSend",
-    args: [`0x${innerTx}`]
-  });
-  const initializer = encodeFunctionData({
-    abi: setupAbi,
-    functionName: "setup",
-    args: [
-      [signerAddress],
-      1n,
-      config.multiSend,
-      multiSendCallData,
-      config.safe4337Module,
-      "0x0000000000000000000000000000000000000000",
-      0n,
-      "0x0000000000000000000000000000000000000000"
-    ]
-  });
-  const deploymentCode = encodePacked(
-    ["bytes", "uint256"],
-    [SAFE_PROXY_CREATION_CODE, BigInt(config.safeL2Singleton)]
-  );
-  const salt = keccak256(
-    encodePacked(
-      ["bytes32", "uint256"],
-      [keccak256(encodePacked(["bytes"], [initializer])), saltNonce]
-    )
-  );
-  return getContractAddress({
-    from: config.safeProxyFactory,
-    salt,
-    bytecode: deploymentCode,
-    opcode: "CREATE2"
-  });
-}
-
-// src/internal/safe/account.ts
-async function buildSafeAccount(signer, chain) {
-  try {
-    const publicClient = createPublicClient({
-      chain: baseSepolia,
-      transport: http(chain.rpcUrl)
-    });
-    return await toSafeSmartAccount({
-      client: publicClient,
-      entryPoint: { address: entryPoint07Address, version: "0.7" },
-      version: "1.4.1",
-      owners: [signer],
-      saltNonce: computeSaltNonce2(signer.address),
-      safeSingletonAddress: SAFE_L2_SINGLETON,
-      safeProxyFactoryAddress: SAFE_PROXY_FACTORY,
-      safeModuleSetupAddress: SAFE_MODULE_SETUP,
-      safe4337ModuleAddress: SAFE_4337_MODULE,
-      safeModules: [],
-      setupTransactions: []
-    });
-  } catch (cause) {
-    throw new CapxulError({
-      code: "NETWORK_ERROR",
-      message: cause instanceof Error ? cause.message : String(cause),
-      cause,
-      details: { chainId: chain.chainId }
-    });
-  }
-}
-function computeSaltNonce2(ownerAddress) {
-  return BigInt(`0x${ownerAddress.toLowerCase().slice(2).padEnd(64, "0")}`);
-}
-function deriveSafeAddress2(signerAddress) {
-  return deriveSafeAddress(signerAddress, defaultSafeDeriveConfig);
-}
-
-// ../platform-kernel/src/ids.ts
-function makePrefixedIdConstructor(prefix, fieldName) {
-  const re = new RegExp(`^${prefix}_[A-Za-z0-9_\\-]+$`);
-  return (raw) => {
-    if (typeof raw !== "string" || !re.test(raw)) {
-      throw new Error(
-        `Invalid ${fieldName}: expected string matching ^${prefix}_[A-Za-z0-9_\\-]+$, got ${String(raw)}`
-      );
-    }
-    return raw;
-  };
-}
-var toAccountId = makePrefixedIdConstructor(
-  "acct",
-  "accountId"
-);
-var toOrganizationId = makePrefixedIdConstructor("org", "organizationId");
-var toMemberId = makePrefixedIdConstructor(
-  "mb",
-  "memberId"
-);
-var toSafeId = makePrefixedIdConstructor(
-  "safe",
-  "safeId"
-);
-var toTreasuryId = makePrefixedIdConstructor(
-  "try",
-  "treasuryId"
-);
-var toApiKeyId = makePrefixedIdConstructor(
-  "ak",
-  "apiKeyId"
-);
-var toOperationId = makePrefixedIdConstructor(
-  "op",
-  "operationId"
-);
-var toCorrelationId = makePrefixedIdConstructor("ctx", "correlationId");
-var toKycProfileId = makePrefixedIdConstructor(
-  "kyc",
-  "kycProfileId"
-);
-var toKybProfileId = makePrefixedIdConstructor(
-  "kyb",
-  "kybProfileId"
-);
-var toExternalAccountId = makePrefixedIdConstructor("ext", "externalAccountId");
-var toPaymentId = makePrefixedIdConstructor(
-  "pay",
-  "paymentId"
-);
-var toWithdrawalId = makePrefixedIdConstructor(
-  "wd",
-  "withdrawalId"
-);
-var toWebhookEndpointId = makePrefixedIdConstructor("we", "webhookEndpointId");
-var toWebhookEventId = makePrefixedIdConstructor("evt", "webhookEventId");
-var toSubAccountId = makePrefixedIdConstructor(
-  "sub",
-  "subAccountId"
-);
-var toVirtualAccountId = makePrefixedIdConstructor("va", "virtualAccountId");
-var toVirtualCardId = makePrefixedIdConstructor(
-  "vc",
-  "virtualCardId"
-);
-var toTransferId = makePrefixedIdConstructor(
-  "txfr",
-  "transferId"
-);
-var toDocumentId = makePrefixedIdConstructor(
-  "doc",
-  "documentId"
-);
-var toBalanceLedgerEntryId = makePrefixedIdConstructor("bal", "balanceLedgerEntryId");
-
-// ../platform-kernel/src/value-objects.ts
-var PHONE_NUMBER_RE = /^\+[1-9]\d{1,14}$/;
-function toPhoneNumber(raw) {
-  if (typeof raw !== "string" || !PHONE_NUMBER_RE.test(raw)) {
-    throw new Error(
-      `Invalid phoneNumber: expected E.164 string matching ^\\+[1-9]\\d{1,14}$, got ${String(raw)}`
-    );
-  }
-  return raw;
-}
-var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-function toEmail(raw) {
-  if (typeof raw !== "string") {
-    throw new Error(
-      `Invalid email: expected string, got ${String(raw)}`
-    );
-  }
-  const lowered = raw.trim().toLowerCase();
-  if (!EMAIL_RE.test(lowered)) {
-    throw new Error(
-      `Invalid email: expected local@domain.tld, got ${String(raw)}`
-    );
-  }
-  return lowered;
-}
-var USERNAME_RE = /^[a-z][a-z0-9_-]{2,29}$/;
-function toUsername(raw) {
-  if (typeof raw !== "string") {
-    throw new Error(
-      `Invalid username: expected string, got ${String(raw)}`
-    );
-  }
-  const lowered = raw.toLowerCase();
-  if (!USERNAME_RE.test(lowered)) {
-    throw new Error(
-      `Invalid username: expected 3-30 chars, letter-first, [a-z0-9_-], got ${String(raw)}`
-    );
-  }
-  return lowered;
-}
-
-// src/core/external-accounts.ts
-function brandExternalAccount(raw) {
-  return {
-    ...raw,
-    id: toExternalAccountId(raw.id),
-    operation: {
-      id: toOperationId(raw.operation.id),
-      status: raw.operation.status,
-      correlationId: toCorrelationId(raw.operation.correlationId)
-    }
-  };
-}
-function createExternalAccountsClient(config = {}) {
-  return {
-    retrieve: async (externalAccountId) => {
-      if (!config._data) {
-        return stub(
-          "externalAccounts.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.externalAccounts.queries.retrievePersonal, {
-          externalAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `external_account ${externalAccountId} not found`
-          }),
-          null
-        ];
-      }
-      return [null, brandExternalAccount(raw)];
-    },
-    remove: async (externalAccountId) => {
-      if (!config._data) {
-        return stub("externalAccounts.remove");
-      }
-      const [err] = await tryCatch(
-        config._data.mutation(api.externalAccounts.mutations.removePersonal, {
-          externalAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      return [null, void 0];
-    }
-  };
-}
-
-// src/core/sub-accounts.ts
-function malformedWireError(reason, raw) {
-  return new CapxulError({
-    code: "PROVIDER_ERROR",
-    message: `convex brandSubAccount failed: ${reason}`,
-    details: {
-      provider: "convex",
-      operation: "brandSubAccount",
-      reason,
-      // PII discipline (`.claude/rules/posthog.md`): user-authored
-      // strings on the wire (`name`, `purpose`) are customer-confidential
-      // — sub-account names like "Q3 Acquisition Reserve" or
-      // "Vendor ABC payments" must not flow into telemetry. We emit a
-      // structural keys-only sample via a strict ALLOWLIST so any future
-      // wire-shape addition (e.g. `recipientEmail`, `tags`) is dropped
-      // by construction rather than leaked through a denylist gap.
-      sample: safeSampleShape(raw)
-    }
-  });
-}
-function safeSampleShape(raw) {
-  if (raw === null || typeof raw !== "object") {
-    return { type: typeof raw };
-  }
-  const r = raw;
-  const balance = r.balance;
-  return {
-    object: typeof r.object === "string" ? r.object : typeof r.object,
-    idPresent: typeof r.id === "string" && r.id.length > 0,
-    // First 4 chars only — enough to distinguish "sub_" prefixed IDs
-    // from accidental other resource IDs without leaking the full ID.
-    idPrefix: typeof r.id === "string" ? r.id.slice(0, 4) : void 0,
-    parentKind: r.parent !== null && typeof r.parent === "object" ? r.parent.kind : typeof r.parent,
-    status: r.status,
-    hasName: typeof r.name === "string",
-    hasPurpose: r.purpose !== void 0,
-    balanceShape: balance !== null && typeof balance === "object" ? Object.keys(balance).sort() : typeof balance,
-    createdAtType: typeof r.createdAt,
-    updatedAtType: typeof r.updatedAt
-  };
-}
-function isMoneyShape(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const m = v;
-  return typeof m.value === "string" && typeof m.currency === "string";
-}
-function isParentShape(v) {
-  if (typeof v !== "object" || v === null) return false;
-  const p = v;
-  return (p.kind === "account" || p.kind === "organization") && typeof p.id === "string";
-}
-function isFiniteNonNegativeInteger(v) {
-  return typeof v === "number" && Number.isFinite(v) && Number.isInteger(v) && v >= 0;
-}
-function validateWireSubAccount(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return { ok: false, reason: "not an object" };
-  }
-  const r = raw;
-  if (r.object !== "sub_account") {
-    return { ok: false, reason: `object must be "sub_account" (got ${String(r.object)})` };
-  }
-  if (typeof r.id !== "string" || r.id.length === 0) {
-    return { ok: false, reason: "id must be a non-empty string" };
-  }
-  if (!isParentShape(r.parent)) {
-    return { ok: false, reason: "parent must be { kind: 'account' | 'organization', id: string }" };
-  }
-  if (typeof r.name !== "string") {
-    return { ok: false, reason: "name must be a string" };
-  }
-  if (r.purpose !== void 0 && typeof r.purpose !== "string") {
-    return { ok: false, reason: "purpose must be a string when present" };
-  }
-  if (r.status !== "active" && r.status !== "archived") {
-    return { ok: false, reason: `status must be "active" | "archived" (got ${String(r.status)})` };
-  }
-  if (!isMoneyShape(r.balance)) {
-    return { ok: false, reason: "balance must be { value: string, currency: string }" };
-  }
-  if (!isFiniteNonNegativeInteger(r.createdAt)) {
-    return { ok: false, reason: "createdAt must be a finite non-negative integer (epoch ms)" };
-  }
-  if (r.updatedAt !== void 0 && !isFiniteNonNegativeInteger(r.updatedAt)) {
-    return { ok: false, reason: "updatedAt must be a finite non-negative integer when present" };
-  }
-  return { ok: true, value: r };
-}
-function brandSubAccount(raw) {
-  const result = validateWireSubAccount(raw);
-  if (!result.ok) {
-    throw malformedWireError(result.reason, raw);
-  }
-  const wire = result.value;
-  return {
-    object: wire.object,
-    id: toSubAccountId(wire.id),
-    parent: wire.parent,
-    name: wire.name,
-    ...wire.purpose !== void 0 ? { purpose: wire.purpose } : {},
-    status: wire.status,
-    balance: wire.balance,
-    createdAt: new Date(wire.createdAt).toISOString()
-  };
-}
-function tryBrandSubAccount(raw) {
-  try {
-    return [null, brandSubAccount(raw)];
-  } catch (err) {
-    if (err instanceof CapxulError && err.code === "PROVIDER_ERROR") {
-      return [err, null];
-    }
-    return [
-      malformedWireError(
-        err instanceof Error ? err.message : String(err),
-        raw
-      ),
-      null
-    ];
-  }
-}
-function createSubAccountsClient(config = {}) {
-  return {
-    retrieve: async (subAccountId) => {
-      if (!config._data) {
-        return stub("subAccounts.retrieve");
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.subAccounts.queries.retrieve, {
-          subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [brandErr, null];
-      }
-      return [null, branded];
-    },
-    remove: async (subAccountId) => {
-      if (!config._data) {
-        return stub("subAccounts.remove");
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.subAccounts.mutations.archive, {
-          subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [brandErr, null];
-      }
-      return [null, branded];
-    }
-  };
-}
-
-// src/core/accounts.ts
-function createAccountExternalAccountsClient(config) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub(
-          "accounts.externalAccounts.create"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(
-          api.externalAccounts.mutations.createPersonal,
-          {
-            kind: input.kind,
-            label: input.label,
-            address: input.address,
-            iban: input.iban,
-            bic: input.bic,
-            accountHolder: input.accountHolder,
-            network: input.network,
-            panToken: input.panToken,
-            last4: input.last4
-          }
-        )
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: "external_account creation returned no resource"
-          }),
-          null
-        ];
-      }
-      return [
-        null,
-        brandExternalAccount(
-          raw
-        )
-      ];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub(
-          "accounts.externalAccounts.list"
-        );
-      }
-      const [err, result] = await tryCatch(
-        config._data.query(api.externalAccounts.queries.listPersonal, {
-          limit: input.limit,
-          cursor: input.cursor
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      const branded = result.data.map(
-        (row) => brandExternalAccount(
-          row
-        )
-      );
-      return [
-        null,
-        {
-          object: "list",
-          data: branded,
-          page: result.page
-        }
-      ];
-    },
-    retrieve: async (externalAccountId) => {
-      if (!config._data) {
-        return stub(
-          "accounts.externalAccounts.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.externalAccounts.queries.retrievePersonal, {
-          externalAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `external_account ${externalAccountId} not found`
-          }),
-          null
-        ];
-      }
-      return [
-        null,
-        brandExternalAccount(
-          raw
-        )
-      ];
-    },
-    remove: async (externalAccountId) => {
-      if (!config._data) {
-        return stub("accounts.externalAccounts.remove");
-      }
-      const [err] = await tryCatch(
-        config._data.mutation(api.externalAccounts.mutations.removePersonal, {
-          externalAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      return [null, void 0];
-    }
-  };
-}
-function createAccountSubAccountsClient(config) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub(
-          "accounts.subAccounts.create"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.subAccounts.mutations.create, {
-          parent: { kind: "account", id: input.accountId },
-          name: input.name,
-          purpose: input.purpose
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: "sub_account creation returned no resource"
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [
-          brandErr,
-          null
-        ];
-      }
-      return [null, branded];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub(
-          "accounts.subAccounts.list"
-        );
-      }
-      const [err, rows] = await tryCatch(
-        config._data.query(api.subAccounts.queries.listByAccount, {
-          accountId: input.accountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      const branded = [];
-      for (const row of rows) {
-        const [brandErr, value] = tryBrandSubAccount(row);
-        if (brandErr) {
-          return [
-            brandErr,
-            null
-          ];
-        }
-        branded.push(value);
-      }
-      return [
-        null,
-        {
-          object: "list",
-          data: branded,
-          page: { hasMore: false }
-        }
-      ];
-    },
-    retrieve: async (subAccountId) => {
-      if (!config._data) {
-        return stub(
-          "accounts.subAccounts.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.subAccounts.queries.retrieve, {
-          subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [
-          brandErr,
-          null
-        ];
-      }
-      return [null, branded];
-    },
-    remove: async (subAccountId) => {
-      if (!config._data) {
-        return stub(
-          "accounts.subAccounts.remove"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.subAccounts.mutations.archive, {
-          subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [
-          brandErr,
-          null
-        ];
-      }
-      return [null, branded];
-    }
-  };
-}
-function createAccountsClient(config = {}) {
-  return {
-    retrieve: async (accountId) => {
-      if (!config._data) {
-        return stub("accounts.retrieve");
-      }
-      try {
-        const account = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        if (account.id !== accountId) {
-          return [
-            new CapxulError({
-              code: "PERMISSION_DENIED",
-              message: "accounts.retrieve currently supports the authenticated caller's own account only.",
-              details: {
-                requestedAccountId: accountId,
-                authenticatedAccountId: account.id
-              }
-            }),
-            null
-          ];
-        }
-        return [null, account];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    lookup: async () => stub("accounts.lookup"),
-    update: async (input) => {
-      if (!config._data) {
-        return stub("accounts.update");
-      }
-      if (input.countryCode !== void 0) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "accounts.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
-            details: { field: "countryCode" }
-          }),
-          null
-        ];
-      }
-      try {
-        const current = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        if (current.id !== input.accountId) {
-          return [
-            new CapxulError({
-              code: "PERMISSION_DENIED",
-              message: "accounts.update currently supports the authenticated caller's own account only.",
-              details: {
-                requestedAccountId: input.accountId,
-                authenticatedAccountId: current.id
-              }
-            }),
-            null
-          ];
-        }
-        await config._data.mutation(api.openfort.mutations.updateProfile, {
-          displayName: input.name,
-          username: input.username
-        });
-        const updated = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        return [null, updated];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    provisionPersonal: async (input) => {
-      if (!config._data) {
-        return stub(
-          "accounts.provisionPersonal"
-        );
-      }
-      if (input.signerProvider.kind !== "local-private-key") {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "accounts.provisionPersonal currently supports local-private-key signer providers only."
-          }),
-          null
-        ];
-      }
-      try {
-        await config._data.mutation(
-          api.safe.mutations.provisionLocalPersonalAccount,
-          {
-            displayName: input.displayName,
-            username: input.username,
-            countryCode: input.countryCode,
-            eoaAddress: input.signerProvider.signerAddress,
-            safeAddress: deriveSafeAddress2(input.signerProvider.signerAddress)
-          }
-        );
-        const account = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        if (!account) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: "accounts.provisionPersonal completed but no account resource was readable."
-            }),
-            null
-          ];
-        }
-        return [null, account];
-      } catch (cause) {
-        return [
-          fromConvexError(cause),
-          null
-        ];
-      }
-    },
-    safes: {
-      retrieve: async (safeId) => {
-        if (!config._data) {
-          return stub("accounts.safes.retrieve");
-        }
-        try {
-          const safe = await config._data.query(
-            api.safe.queries.retrieveAccountSafe,
-            { safeId }
-          );
-          if (!safe) {
-            return [
-              new CapxulError({
-                code: "NOT_FOUND",
-                message: `safe ${safeId} not found`
-              }),
-              null
-            ];
-          }
-          return [null, safe];
-        } catch (cause) {
-          return [
-            fromConvexError(cause),
-            null
-          ];
-        }
-      }
-    },
-    kycProfiles: {
-      create: async () => stub("accounts.kycProfiles.create"),
-      retrieve: async () => stub("accounts.kycProfiles.retrieve")
-    },
-    externalAccounts: createAccountExternalAccountsClient(config),
-    subAccounts: createAccountSubAccountsClient(config),
-    balanceLedger: {
-      list: async (input) => {
-        if (!config._data) {
-          return stub(
-            "accounts.balanceLedger.list"
-          );
-        }
-        try {
-          const accountId = input.accountId.replace(/^acct_/, "");
-          const page = await config._data.query(
-            api.balanceLedger.queries.listForAccount,
-            { accountId, limit: input.limit, cursor: input.cursor }
-          );
-          return [null, page];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      retrieve: async (entryId) => {
-        if (!config._data) {
-          return stub(
-            "accounts.balanceLedger.retrieve"
-          );
-        }
-        try {
-          const entry = await config._data.query(
-            api.balanceLedger.queries.retrieve,
-            { entryId }
-          );
-          if (!entry) {
-            return [
-              new CapxulError({
-                code: "NOT_FOUND",
-                message: `balance_ledger_entry ${entryId} not found`
-              }),
-              null
-            ];
-          }
-          return [null, entry];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      }
-    }
-  };
-}
-
-// src/core/api-keys.ts
-function createApiKeysClient() {
-  return {
-    create: async () => stub("apiKeys.create"),
-    retrieve: async () => stub("apiKeys.retrieve"),
-    list: async () => stub("apiKeys.list"),
-    revoke: async () => stub("apiKeys.revoke")
-  };
-}
-function createDefaultDataClient(convexUrl, jwt) {
-  const client = new ConvexHttpClient(convexUrl);
-  client.setAuth(jwt);
-  return client;
-}
-
-// src/transport.ts
-function makeHttpTransport(config) {
-  switch (config.mode) {
-    case "build-time-urls":
-      return makeBuildTimeUrlsTransport(config);
-    case "publishable-key":
-      return makePublishableKeyTransport(config);
-    default:
-      return assertNever(config);
-  }
-}
-function createLifecycle(initial) {
-  let state = initial;
-  const listeners = /* @__PURE__ */ new Set();
-  return {
-    getState: () => state,
-    setState: (next) => {
-      if (Object.is(state, next)) return;
-      state = next;
-      for (const listener of listeners) listener();
-    },
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    }
-  };
-}
-function makeBuildTimeUrlsTransport(config) {
-  if (!config.authBaseUrl || config.authBaseUrl.trim().length === 0) {
-    throw invalidConfigError(
-      "authBaseUrl",
-      "build-time-urls transport requires a non-empty authBaseUrl."
-    );
-  }
-  if (!config.convexUrl || config.convexUrl.trim().length === 0) {
-    throw invalidConfigError(
-      "convexUrl",
-      "build-time-urls transport requires a non-empty convexUrl."
-    );
-  }
-  const authBaseUrl = stripTrailingSlash(config.authBaseUrl);
-  const convexUrl = config.convexUrl;
-  const fetchImpl = config.fetchImpl ?? globalThis.fetch;
-  const runtime = { authBaseUrl, convexUrl };
-  const lifecycle = createLifecycle({ status: "ready", runtime });
-  let dataClient = null;
-  return {
-    authBaseUrl,
-    convexUrl,
-    ensureRuntime: async () => runtime,
-    fetch: (path, init) => fetchImpl(resolveUrl(authBaseUrl, path), init),
-    getState: lifecycle.getState,
-    subscribe: lifecycle.subscribe,
-    getDataClient: () => dataClient,
-    markAuthenticated: ({ dataClient: nextDataClient }) => {
-      if (nextDataClient !== void 0) dataClient = nextDataClient;
-      lifecycle.setState({ status: "authenticated", runtime });
-    },
-    clearAuth: () => {
-      dataClient = null;
-      lifecycle.setState({ status: "ready", runtime });
-    }
-  };
-}
-function makePublishableKeyTransport(config) {
-  const publishableKey = config.publishableKey?.trim();
-  if (!publishableKey) {
-    throw invalidConfigError(
-      "publishableKey",
-      "publishable-key transport requires a non-empty publishableKey."
-    );
-  }
-  const fetchImpl = config.fetchImpl ?? globalThis.fetch;
-  const bootstrapUrl = normalizeBootstrapUrl(
-    config.bootstrapUrl ?? `${CAPXUL_API_BASE_URL}/v1/client/bootstrap`
-  );
-  let authBaseUrl = "";
-  let convexUrl = "";
-  let bootstrapPromise = null;
-  let dataClient = null;
-  const lifecycle = createLifecycle({ status: "idle" });
-  async function ensureBootstrap() {
-    if (bootstrapPromise) return await bootstrapPromise;
-    lifecycle.setState({ status: "bootstrapping" });
-    const attempt = (async () => {
-      const response = await fetchImpl(bootstrapUrl, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ publishableKey })
-      });
-      if (!response.ok) {
-        throw await bootstrapResponseError(response, bootstrapUrl);
-      }
-      const body = await readBootstrapSuccessBody(response);
-      if (typeof body.authBaseUrl !== "string" || body.authBaseUrl.trim().length === 0) {
-        throw bootstrapContractError(
-          "authBaseUrl",
-          "/v1/client/bootstrap returned no authBaseUrl."
-        );
-      }
-      if (typeof body.convexUrl !== "string" || body.convexUrl.trim().length === 0) {
-        throw bootstrapContractError(
-          "convexUrl",
-          "/v1/client/bootstrap returned no convexUrl."
-        );
-      }
-      authBaseUrl = stripTrailingSlash(body.authBaseUrl);
-      convexUrl = body.convexUrl;
-      const runtime = { authBaseUrl, convexUrl };
-      lifecycle.setState({ status: "ready", runtime });
-      return runtime;
-    })();
-    bootstrapPromise = attempt.catch((err) => {
-      const error = normalizeBootstrapThrownError(err);
-      bootstrapPromise = null;
-      lifecycle.setState({
-        status: "error",
-        error
-      });
-      throw error;
-    });
-    return await bootstrapPromise;
-  }
-  return {
-    get authBaseUrl() {
-      return authBaseUrl;
-    },
-    get convexUrl() {
-      return convexUrl;
-    },
-    ensureRuntime: ensureBootstrap,
-    fetch: async (path, init) => {
-      const resolved = await ensureBootstrap();
-      return await fetchImpl(resolveUrl(resolved.authBaseUrl, path), init);
-    },
-    getState: lifecycle.getState,
-    subscribe: lifecycle.subscribe,
-    getDataClient: () => dataClient,
-    markAuthenticated: ({ dataClient: nextDataClient }) => {
-      const current = lifecycle.getState();
-      if (current.status !== "ready" && current.status !== "authenticated") {
-        throw internalTransportError(
-          `markAuthenticated() called from status="${current.status}". Expected "ready" or "authenticated".`
-        );
-      }
-      if (nextDataClient !== void 0) dataClient = nextDataClient;
-      lifecycle.setState({
-        status: "authenticated",
-        runtime: current.runtime
-      });
-    },
-    clearAuth: () => {
-      const current = lifecycle.getState();
-      dataClient = null;
-      if (current.status === "authenticated") {
-        lifecycle.setState({ status: "ready", runtime: current.runtime });
-      }
-    }
-  };
-}
-function stripTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
-}
-function normalizeBootstrapUrl(url) {
-  const normalized = stripTrailingSlash(url.trim());
-  if (!isAbsoluteHttpUrl(normalized)) {
-    throw invalidConfigError(
-      "bootstrapUrl",
-      "publishable-key transport requires an absolute http(s) bootstrapUrl."
-    );
-  }
-  return normalized;
-}
-function isAbsoluteHttpUrl(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-function resolveUrl(authBaseUrl, path) {
-  if (path.startsWith("http://") || path.startsWith("https://")) {
-    return path;
-  }
-  return `${authBaseUrl}${path}`;
-}
-function assertNever(value) {
-  throw internalTransportError(
-    `Unhandled BrowserCapxulConfig.mode: ${String(value.mode)}.`
-  );
-}
-function invalidConfigError(field, reason) {
-  return new CapxulError({
-    code: "INVALID_INPUT",
-    message: `Invalid ${field}: ${reason}`,
-    details: { source: "sdk-config", field, reason }
-  });
-}
-function bootstrapContractError(field, message) {
-  return new CapxulError({
-    code: "INVALID_INPUT",
-    message,
-    details: {
-      source: "backend-bootstrap",
-      phase: "publishable-key-bootstrap",
-      field,
-      reason: message
-    }
-  });
-}
-function internalTransportError(reason) {
-  return new CapxulError({
-    code: "INTERNAL_ERROR",
-    message: `Internal error: ${reason}`,
-    details: { source: "sdk-transport", reason }
-  });
-}
-async function bootstrapResponseError(response, bootstrapUrl) {
-  const envelope = await readBootstrapErrorEnvelope(response);
-  const wireCode = readNonEmptyString(envelope?.error?.code);
-  const normalized = normalizeBootstrapErrorCode(wireCode);
-  const message = readNonEmptyString(envelope?.error?.message) ?? `${bootstrapUrl} failed with HTTP ${response.status}.`;
-  const backendDetails = readRecord(envelope?.error?.details);
-  return new CapxulError({
-    code: normalized.code,
-    message,
-    details: {
-      ...backendDetails,
-      source: "backend-bootstrap",
-      phase: "publishable-key-bootstrap",
-      httpStatus: response.status,
-      ...normalized.wireCode ? { wireCode: normalized.wireCode } : {}
-    },
-    operationId: readNonEmptyString(envelope?.error?.operationId),
-    correlationId: readNonEmptyString(envelope?.error?.correlationId),
-    retryable: typeof envelope?.error?.retryable === "boolean" ? envelope.error.retryable : void 0
-  });
-}
-async function readBootstrapErrorEnvelope(response) {
-  try {
-    const parsed = await response.json();
-    return typeof parsed === "object" && parsed !== null ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-async function readBootstrapSuccessBody(response) {
-  try {
-    const parsed = await response.json();
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch {
-    throw bootstrapContractError(
-      "body",
-      "/v1/client/bootstrap returned invalid JSON."
-    );
-  }
-}
-function normalizeBootstrapThrownError(error) {
-  if (error instanceof CapxulError) return error;
-  return new CapxulError({
-    code: "NETWORK_ERROR",
-    message: "Publishable-key bootstrap network failure.",
-    cause: error,
-    details: {
-      source: "bootstrap-network",
-      phase: "publishable-key-bootstrap"
-    }
-  });
-}
-function normalizeBootstrapErrorCode(wireCode) {
-  if (wireCode === "INTERNAL_SERVER_ERROR") {
-    return { code: "INTERNAL_ERROR", wireCode };
-  }
-  if (wireCode && isCapxulErrorCode(wireCode)) {
-    return { code: wireCode };
-  }
-  return wireCode ? { code: "UNKNOWN", wireCode } : { code: "UNKNOWN" };
-}
-var CAPXUL_ERROR_CODES = /* @__PURE__ */ new Set([
-  "NOT_AUTHENTICATED",
-  "EMAIL_DELIVERY_FAILED",
-  "PROFILE_NOT_FOUND",
-  "SMART_ACCOUNT_MISSING",
-  "PLAYER_NOT_FOUND",
-  "ACCOUNT_NOT_FOUND",
-  "PROVIDER_ERROR",
-  "INVALID_INPUT",
-  "ENV_MISSING",
-  "NOT_IMPLEMENTED",
-  "VERIFICATION_REQUIRED",
-  "INSUFFICIENT_BALANCE",
-  "INVALID_RECIPIENT",
-  "TRANSACTION_FAILED",
-  "RATE_LIMITED",
-  "NETWORK_ERROR",
-  "UNKNOWN",
-  "PERMISSION_DENIED",
-  "API_KEY_INVALID",
-  "API_KEY_EXPIRED",
-  "IDEMPOTENCY_CONFLICT",
-  "NOT_FOUND",
-  "OPERATION_CANCELED",
-  "OPERATION_TIMEOUT",
-  "ACTION_REQUIRED",
-  "KYC_REQUIRED",
-  "POLICY_DENIED",
-  "SAFE_NOT_READY",
-  "PROVIDER_UNAVAILABLE",
-  "PROVIDER_REJECTED",
-  "RECONCILIATION_FAILED",
-  "INTERNAL_ERROR",
-  "QUOTE_EXPIRED",
-  "QUOTE_NOT_FOUND"
-]);
-function isCapxulErrorCode(value) {
-  return CAPXUL_ERROR_CODES.has(value);
-}
-function readRecord(value) {
-  return typeof value === "object" && value !== null ? value : null;
-}
-function readNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-
-// src/core/auth.ts
-function createAuthClient(config = {}) {
-  let dataClient = config._data ?? null;
-  const sessionStore = config.auth?.sessionStore ?? createMemorySessionStore();
-  const getTransport = createTransportProvider(config);
-  return {
-    sendOtp: async (input, options) => {
-      const transport = getTransport();
-      if (!transport) {
-        return stub("auth.sendOtp");
-      }
-      return await postBetterAuth(
-        transport,
-        "/email-otp/send-verification-otp",
-        { email: input.email, type: "sign-in" },
-        "EMAIL_DELIVERY_FAILED",
-        options?.signal
-      );
-    },
-    verifyOtp: async (input, options) => {
-      const transport = getTransport();
-      if (!transport) {
-        return stub("auth.verifyOtp");
-      }
-      const [signInError, signIn] = await postBetterAuth(
-        transport,
-        "/sign-in/email-otp",
-        { email: input.email, otp: input.otp },
-        "NOT_AUTHENTICATED",
-        options?.signal
-      );
-      if (signInError) return [signInError, null];
-      if (!signIn?.token || !signIn.user?.id) {
-        return [
-          new CapxulError({
-            code: "NOT_AUTHENTICATED",
-            message: "BetterAuth did not return a usable session."
-          }),
-          null
-        ];
-      }
-      const [convexError, convexJwt] = await exchangeConvexToken(
-        transport,
-        config,
-        signIn.token,
-        options?.signal
-      );
-      if (convexError) return [convexError, null];
-      const session = {
-        authUserId: signIn.user.id,
-        email: signIn.user.email,
-        token: signIn.token,
-        convexJwt,
-        expiresAt: new Date(
-          Date.now() + 30 * 24 * 60 * 60 * 1e3
-        ).toISOString()
-      };
-      sessionStore.set(session);
-      if (!dataClient) {
-        try {
-          const convexUrl = transport.convexUrl;
-          if (!convexUrl || !session.convexJwt) {
-            return [
-              new CapxulError({
-                code: "NETWORK_ERROR",
-                message: "Cannot create data client: missing convex URL or JWT."
-              }),
-              null
-            ];
-          }
-          dataClient = createDefaultDataClient(convexUrl, session.convexJwt);
-          mutableConfig(config)._data = dataClient;
-        } catch (cause) {
-          return [
-            new CapxulError({
-              code: "NETWORK_ERROR",
-              message: "Authenticated data client creation failed.",
-              cause
-            }),
-            null
-          ];
-        }
-      } else {
-        const injected = dataClient;
-        if (typeof injected.refreshAuth === "function") {
-          injected.refreshAuth();
-        } else if (typeof injected.setAuth === "function" && session.convexJwt) {
-          injected.setAuth(session.convexJwt);
-        }
-      }
-      transport.markAuthenticated({ dataClient });
-      if (!dataClient) {
-        return [
-          new CapxulError({
-            code: "NOT_AUTHENTICATED",
-            message: "Auth bootstrap requires an authenticated Convex data client."
-          }),
-          null
-        ];
-      }
-      try {
-        const resolution = await dataClient.mutation(
-          api.authBootstrap.resolveAfterOtp,
-          {
-            email: session.email,
-            sessionToken: session.token
-          }
-        );
-        if (resolution.kind === "existing_member") {
-          return [null, { ...resolution, session }];
-        }
-        return [null, { ...resolution, session }];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    completeBootstrap: async (input) => {
-      const session = sessionStore.get();
-      const data = dataClient ?? config._data;
-      if (!session || !data) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "completeBootstrap requires the OTP-verified session that issued the bootstrap token."
-          }),
-          null
-        ];
-      }
-      const signerAddress = config.signer?.address;
-      if (!signerAddress) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "completeBootstrap requires a signer to be configured on the client."
-          }),
-          null
-        ];
-      }
-      try {
-        const safeAddress = deriveSafeAddress2(signerAddress);
-        if (!data.action) {
-          return [
-            new CapxulError({
-              code: "INVALID_INPUT",
-              message: "completeBootstrap requires a data client that can execute Convex actions."
-            }),
-            null
-          ];
-        }
-        const result = await data.action(api.authBootstrap.completeBootstrap, {
-          bootstrapToken: input.bootstrapToken,
-          sessionToken: session.token,
-          username: input.username,
-          displayName: input.displayName,
-          countryCode: input.countryCode,
-          signerProvider: {
-            kind: "local-private-key",
-            signerAddress,
-            safeAddress
-          }
-        });
-        return [null, { kind: "authenticated", session, ...result }];
-      } catch (cause) {
-        return [
-          fromConvexError(cause),
-          null
-        ];
-      }
-    },
-    getSession: async () => [null, sessionStore.get()],
-    signOut: async () => {
-      sessionStore.clear();
-      dataClient = null;
-      mutableConfig(config)._data = void 0;
-      const transport = getTransport();
-      transport?.clearAuth();
-      return [null, void 0];
-    },
-    serviceTokenMint: async () => stub("auth.serviceTokenMint"),
-    getDataClient: () => dataClient
-  };
-}
-function createMemorySessionStore() {
-  let current = null;
-  return {
-    get: () => current,
-    set: (session) => {
-      current = session;
-    },
-    clear: () => {
-      current = null;
-    }
-  };
-}
-function createTransportProvider(config) {
-  let cached = config._transport ?? null;
-  return () => {
-    if (cached) return cached;
-    const baseUrl = config.auth?.baseUrl;
-    if (baseUrl) {
-      cached = makeHttpTransport({
-        mode: "build-time-urls",
-        authBaseUrl: betterAuthRoot(baseUrl),
-        convexUrl: baseUrl,
-        fetchImpl: config.fetch
-      });
-      return cached;
-    }
-    if (!config.publishableKey) return null;
-    cached = makeHttpTransport({
-      mode: "publishable-key",
-      publishableKey: config.publishableKey,
-      fetchImpl: config.fetch
-    });
-    return cached;
-  };
-}
-function betterAuthRoot(rawBaseUrl) {
-  const trimmed = rawBaseUrl.replace(/\/+$/, "");
-  return trimmed.endsWith("/api/auth") ? trimmed : `${trimmed}/api/auth`;
-}
-async function postBetterAuth(transport, path, body, code, signal) {
-  try {
-    const response = await transport.fetch(path, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body),
-      signal
-    });
-    const text = await response.text();
-    if (!response.ok) {
-      const parsedError = parseBetterAuthError(text);
-      return [
-        new CapxulError({
-          code: parsedError.code ?? code,
-          message: parsedError.message ?? `BetterAuth ${path} failed with HTTP ${response.status}.`,
-          details: parsedError.details,
-          retryable: parsedError.retryable
-        }),
-        null
-      ];
-    }
-    return [null, text ? JSON.parse(text) : void 0];
-  } catch (cause) {
-    if (cause instanceof CapxulError) {
-      return [cause, null];
-    }
-    return [
-      new CapxulError({
-        code: "NETWORK_ERROR",
-        message: `BetterAuth ${path} network failure.`,
-        cause
-      }),
-      null
-    ];
-  }
-}
-function parseBetterAuthError(text) {
-  if (!text.trim()) {
-    return {};
-  }
-  try {
-    const body = JSON.parse(text);
-    if (!body || typeof body !== "object") {
-      return {};
-    }
-    const record = body;
-    const nested = record.error && typeof record.error === "object" ? record.error : record;
-    const code = typeof nested.code === "string" ? nested.code : void 0;
-    const message = typeof nested.message === "string" ? nested.message : void 0;
-    const details = nested.details && typeof nested.details === "object" ? nested.details : void 0;
-    const correlationId = typeof nested.correlationId === "string" ? nested.correlationId : void 0;
-    const retryable = typeof nested.retryable === "boolean" ? nested.retryable : void 0;
-    return {
-      code: isCapxulErrorCode2(code) ? code : void 0,
-      message,
-      details,
-      correlationId,
-      retryable
-    };
-  } catch {
-    return {};
-  }
-}
-function isCapxulErrorCode2(code) {
-  return code === "NOT_AUTHENTICATED" || code === "EMAIL_DELIVERY_FAILED" || code === "INVALID_INPUT" || code === "RATE_LIMITED" || code === "NETWORK_ERROR" || code === "API_KEY_INVALID" || code === "API_KEY_EXPIRED" || code === "INTERNAL_ERROR" || code === "ENV_MISSING" || code === "UNKNOWN" || code === "PROVIDER_ERROR";
-}
-async function exchangeConvexToken(transport, config, token, signal) {
-  const path = config.auth?.convexTokenUrl ?? "/convex/token";
-  try {
-    const response = await transport.fetch(path, {
-      headers: { authorization: `Bearer ${token}` },
-      signal
-    });
-    if (!response.ok) {
-      return [
-        new CapxulError({
-          code: "NOT_AUTHENTICATED",
-          message: `Convex token exchange failed with HTTP ${response.status}.`
-        }),
-        null
-      ];
-    }
-    const body = await response.json();
-    if (typeof body.token !== "string") {
-      return [
-        new CapxulError({
-          code: "NOT_AUTHENTICATED",
-          message: "Convex token exchange returned no token."
-        }),
-        null
-      ];
-    }
-    return [null, body.token];
-  } catch (cause) {
-    if (cause instanceof CapxulError) {
-      return [cause, null];
-    }
-    return [
-      new CapxulError({
-        code: "NETWORK_ERROR",
-        message: "Convex token exchange network failure.",
-        cause
-      }),
-      null
-    ];
-  }
-}
-function mutableConfig(config) {
-  return config;
-}
-
-// src/core/auth-service.ts
-var AuthService = class {
-  authClient;
-  sessionStore;
-  config;
-  constructor(config = {}) {
-    this.config = config;
-    this.sessionStore = config.auth?.sessionStore ?? createMemorySessionStore2();
-    this.authClient = createAuthClient({
-      ...config,
-      auth: { ...config.auth, sessionStore: this.sessionStore }
-    });
-  }
-  async sendOtp(email, options) {
-    const [err] = await this.authClient.sendOtp({ email }, options);
-    if (err) throw err;
-  }
-  async verifyOtp(email, otp, options) {
-    const [err, result] = await this.authClient.verifyOtp(
-      { email, otp },
-      options
-    );
-    if (err) throw err;
-    return result;
-  }
-  async completeBootstrap(params, signer) {
-    if (signer) {
-      const tempClient = createAuthClient({
-        ...this.config,
-        signer,
-        auth: { ...this.config.auth, sessionStore: this.sessionStore }
-      });
-      const [err2, result2] = await tempClient.completeBootstrap(params);
-      if (err2) throw err2;
-      return result2;
-    }
-    const [err, result] = await this.authClient.completeBootstrap(params);
-    if (err) throw err;
-    return result;
-  }
-  /**
-   * Clears the persisted session and, when a transport was pre-injected,
-   * drops the cached auth header.
-   *
-   * **Transport safety note:** `clearAuth()` is only invoked when
-   * `config._transport` was supplied at construction (e.g. by the React
-   * provider). If `AuthService` is instantiated directly in a Node/CLI
-   * context without an injected transport, the transport-side auth cache
-   * is the caller's responsibility.
-   */
-  async signOut() {
-    if (!this.config._transport) {
-      const [err] = await this.authClient.signOut();
-      if (err) throw err;
-      mutableConfig2(this.config)._data = void 0;
-      return;
-    }
-    this.sessionStore.clear();
-    this.config._transport.clearAuth();
-  }
-  async getSession() {
-    const [err, session] = await this.authClient.getSession();
-    if (err) throw err;
-    return session;
-  }
-};
-function mutableConfig2(config) {
-  return config;
-}
-function createMemorySessionStore2() {
-  let current = null;
-  return {
-    get: () => current,
-    set: (session) => {
-      current = session;
-    },
-    clear: () => {
-      current = null;
-    }
-  };
-}
-
-// src/core/documents.ts
-function requireInvoiceHash(row) {
-  if (!row.invoiceHash) {
-    throw new CapxulError({
-      code: "INVALID_INPUT",
-      message: `invoice document ${row.documentId ?? row._id} is missing its canonical invoiceHash`
-    });
-  }
-  return row.invoiceHash;
-}
-function mapInvoiceRow(row) {
-  const status = row.status === "cancelled" ? "canceled" : row.status === "pending" ? "open" : row.status === "overdue" ? "expired" : row.status;
-  return {
-    object: "document",
-    id: row.documentId ?? row._id,
-    type: "invoice",
-    owner: {
-      kind: row.scope === "org" ? "organization" : "account",
-      id: row.orgId ?? row.payeeEmail ?? row.payeeLabel
-    },
-    recipient: { email: row.payerEmail },
-    amount: {
-      value: row.amount,
-      currency: row.currency
-    },
-    reference: row.note,
-    lineItems: row.items,
-    invoiceHash: requireInvoiceHash(row),
-    dueAt: row.dueDate,
-    status,
-    createdAt: new Date(row.createdAt).toISOString()
-  };
-}
-function mapDocumentError(cause) {
-  return fromConvexError(cause);
-}
-function createDocumentsClient(config = {}) {
-  return {
-    create: async (input) => {
-      if (!config._data) return stub("documents.create");
-      if (input.type !== "invoice") {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "documents.create currently supports personal invoice documents only."
-          }),
-          null
-        ];
-      }
-      if (!("email" in input.recipient)) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "personal invoice documents currently require an email recipient."
-          }),
-          null
-        ];
-      }
-      try {
-        const created = await config._data.mutation(
-          api.paymentRecords.mutations.createInvoice,
-          {
-            scope: "personal",
-            payerEmail: input.recipient.email,
-            amount: input.amount.value,
-            currency: input.amount.currency,
-            dueDate: input.dueAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-            note: input.reference,
-            items: input.lineItems
-          }
-        );
-        const row = await config._data.query(
-          api.paymentRecords.queries.getInvoiceByDocumentId,
-          { documentId: created.documentId }
-        );
-        if (!row) throw new Error("created invoice was not readable");
-        return [null, mapInvoiceRow(row)];
-      } catch (cause) {
-        return [mapDocumentError(cause), null];
-      }
-    },
-    retrieve: async (documentId) => {
-      if (!config._data)
-        return stub("documents.retrieve");
-      try {
-        const row = await config._data.query(
-          api.paymentRecords.queries.getInvoiceByDocumentId,
-          { documentId }
-        );
-        if (!row) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: `document ${documentId} not found`
-            }),
-            null
-          ];
-        }
-        return [null, mapInvoiceRow(row)];
-      } catch (cause) {
-        return [mapDocumentError(cause), null];
-      }
-    },
-    list: async (input = {}) => {
-      if (!config._data)
-        return stub("documents.list");
-      try {
-        if (input.type && input.type !== "invoice") {
-          return [null, { object: "list", data: [], page: { hasMore: false } }];
-        }
-        const rows = await config._data.query(
-          api.paymentRecords.queries.listMyInvoices,
-          {
-            limit: input.limit,
-            cursor: input.cursor
-          }
-        );
-        const page = rows;
-        const data = page.data.map((row) => mapInvoiceRow(row));
-        return [null, { object: "list", data, page: page.page }];
-      } catch (cause) {
-        return [mapDocumentError(cause), null];
-      }
-    },
-    cancel: async (documentId) => {
-      if (!config._data) return stub("documents.cancel");
-      try {
-        const row = await config._data.mutation(
-          api.paymentRecords.mutations.cancelInvoice,
-          { documentId }
-        );
-        return [null, mapInvoiceRow(row)];
-      } catch (cause) {
-        return [mapDocumentError(cause), null];
-      }
-    }
-  };
-}
-function createOrgDocumentsClient(_config = {}) {
-  return {
-    create: async () => stub("organizations.documents.create"),
-    retrieve: async () => stub("organizations.documents.retrieve"),
-    list: async () => stub("organizations.documents.list"),
-    cancel: async () => stub("organizations.documents.cancel")
-  };
-}
-
-// src/core/me.ts
-function createMeClient(config = {}) {
-  return {
-    get: async () => {
-      if (!config._data) {
-        return stub("me.get");
-      }
-      try {
-        const account = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        return [null, account];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    update: async (input) => {
-      if (!config._data) {
-        return stub("me.update");
-      }
-      if (input.countryCode !== void 0) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "me.update does not support countryCode yet \u2014 backend mutation only patches displayName and username.",
-            details: { field: "countryCode" }
-          }),
-          null
-        ];
-      }
-      try {
-        await config._data.mutation(api.openfort.mutations.updateProfile, {
-          displayName: input.name,
-          username: input.username
-        });
-        const account = await config._data.query(
-          api.openfort.queries.getMyAccount,
-          {}
-        );
-        return [null, account];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    }
-  };
-}
-
-// src/core/operations.ts
-function createOperationsClient(config = {}) {
-  const retrieve = async (operationId) => {
-    if (!config._data) {
-      return stub("operations.retrieve");
-    }
-    try {
-      const operation = await config._data.query(api.operations.queries.retrieve, {
-        operationId
-      });
-      if (!operation) {
-        return [new CapxulError({
-          code: "NOT_FOUND",
-          message: `operation ${operationId} not found`
-        }), null];
-      }
-      return [null, operation];
-    } catch (cause) {
-      return [fromConvexError(cause), null];
-    }
-  };
-  return {
-    retrieve,
-    wait: async (operationId, input = {}) => {
-      if (!config._data) {
-        return stub("operations.wait");
-      }
-      const until = new Set(
-        input.until ?? ["succeeded", "failed", "canceled", "indexed"]
-      );
-      const timeoutMs = (input.timeoutSeconds ?? 60) * 1e3;
-      const pollIntervalMs = input.pollIntervalMs ?? 1e3;
-      const deadline = Date.now() + timeoutMs;
-      while (Date.now() <= deadline) {
-        const [error, operation] = await retrieve(operationId);
-        if (error) {
-          return [error, null];
-        }
-        if (until.has(operation.status)) {
-          return [null, operation];
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-      }
-      return [new CapxulError({
-        code: "OPERATION_TIMEOUT",
-        message: `operation ${operationId} did not reach a terminal state before the timeout`,
-        details: {
-          operationId,
-          timeoutSeconds: input.timeoutSeconds ?? 60,
-          pollIntervalMs
-        }
-      }), null];
-    }
-  };
-}
-function toTokenUnits(value, decimals = 6) {
-  return parseUnits(value, decimals);
-}
-
-// src/core/token-registry.ts
-function resolvePaymentToken(currency) {
-  const normalized = currency.trim().toUpperCase();
-  if (normalized === "USD" || normalized === "USDC") {
-    return {
-      address: TEST_USDC_ADDRESS.toLowerCase(),
-      decimals: 6,
-      symbol: "USDC"
-    };
-  }
-  throw new CapxulError({
-    code: "NOT_IMPLEMENTED",
-    message: `Currency ${currency} is not yet supported by the token registry.`,
-    details: { currency: normalized }
-  });
-}
-function createCapxulBundler(config) {
-  const paymaster = createPaymasterClient({
-    transport: http(config.rpcUrl)
-  });
-  return createBundlerClient({
-    chain: baseSepolia,
-    transport: http(config.rpcUrl),
-    paymaster,
-    paymasterContext: { policyId: config.gasPolicyId }
-  });
-}
-var CAPXUL_PAYMENTS_SEND_ABI = [
-  {
-    name: "send",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "token", type: "address" },
-      { name: "recipient", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "documentHash", type: "bytes32" },
-      { name: "paymentType", type: "uint8" }
-    ],
-    outputs: []
-  }
-];
-var ERC20_APPROVE_ABI = [
-  {
-    name: "approve",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }]
-  }
-];
-function encodeOwnerTransferCalls(params) {
-  const documentHash = params.documentHash ?? "0x" + "0".repeat(64);
-  const paymentType = params.paymentType ?? 0;
-  const approve = encodeFunctionData({
-    abi: ERC20_APPROVE_ABI,
-    functionName: "approve",
-    args: [CAPXUL_PAYMENTS_ADDRESS, params.amount]
-  });
-  const send = encodeFunctionData({
-    abi: CAPXUL_PAYMENTS_SEND_ABI,
-    functionName: "send",
-    args: [
-      params.tokenAddress,
-      params.recipientAddress,
-      params.amount,
-      documentHash,
-      paymentType
-    ]
-  });
-  return [
-    {
-      to: params.tokenAddress.toLowerCase(),
-      data: approve,
-      value: 0n
-    },
-    {
-      to: CAPXUL_PAYMENTS_ADDRESS,
-      data: send,
-      value: 0n
-    }
-  ];
-}
-
-// src/internal/safe/operations.ts
-var USER_OP_RECEIPT_TIMEOUT_MS = 12e4;
-async function transferAsOwner(config, params) {
-  try {
-    const safeAccount = await buildSafeAccount(config.signer, config.signing);
-    const bundler = createCapxulBundler(config.signing);
-    const calls = encodeOwnerTransferCalls(params);
-    const userOpHash = await bundler.sendUserOperation({
-      account: safeAccount,
-      calls
-    });
-    const receipt = await bundler.waitForUserOperationReceipt({
-      hash: userOpHash,
-      timeout: USER_OP_RECEIPT_TIMEOUT_MS
-    });
-    return {
-      txHash: receipt.receipt.transactionHash,
-      userOpHash,
-      blockNumber: Number(receipt.receipt.blockNumber),
-      success: receipt.success,
-      logs: receipt.receipt.logs
-    };
-  } catch (cause) {
-    throw new CapxulError({
-      code: "NETWORK_ERROR",
-      message: cause instanceof Error ? cause.message : String(cause),
-      cause
-    });
-  }
-}
-
-// src/core/payments.ts
-function createPaymentsClient(config = {}) {
-  return {
-    create: async (input) => {
-      if (!config._data || !config.signer || !config.signing) {
-        return stub("payments.create");
-      }
-      let created = null;
-      let submitted = null;
-      try {
-        created = await config._data.mutation(api.payments.mutations.create, {
-          to: input.to,
-          amount: input.amount,
-          reference: input.reference,
-          idempotencyKey: input.idempotencyKey,
-          source: input.source
-        });
-        if (!created) {
-          return [
-            new CapxulError({
-              code: "NETWORK_ERROR",
-              message: "payments.create returned no payment resource"
-            }),
-            null
-          ];
-        }
-        if (created.status !== "processing" || created.operation.status !== "processing") {
-          return [null, created];
-        }
-        const currentSigner = await config._data.query(
-          api.safe.queries.getMySignerAddress,
-          {}
-        );
-        if (!currentSigner?.address) {
-          throw new CapxulError({
-            code: "PERMISSION_DENIED",
-            message: "No signer is registered for the authenticated account.",
-            details: { paymentId: created.id }
-          });
-        }
-        if (getAddress(currentSigner.address) !== getAddress(config.signer.address)) {
-          throw new CapxulError({
-            code: "PERMISSION_DENIED",
-            message: "Configured signer does not match the authenticated account signer.",
-            details: {
-              paymentId: created.id,
-              expectedSignerAddress: currentSigner.address,
-              actualSignerAddress: config.signer.address
-            }
-          });
-        }
-        const submission = await config._data.query(
-          api.payments.queries.prepareSubmission,
-          {
-            paymentId: created.id
-          }
-        );
-        if (!submission?.recipientAddress) {
-          throw new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "payments.prepareSubmission returned no recipient address.",
-            details: { paymentId: created.id }
-          });
-        }
-        const token = resolvePaymentToken(submission.amount.currency);
-        const transfer = await transferAsOwner(
-          {
-            signer: config.signer,
-            signing: config.signing
-          },
-          {
-            tokenAddress: token.address,
-            recipientAddress: submission.recipientAddress,
-            amount: toTokenUnits(submission.amount.value, token.decimals)
-          }
-        );
-        if (!transfer.success) {
-          throw new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "Bundler submission did not succeed.",
-            details: {
-              paymentId: created.id,
-              txHash: transfer.txHash,
-              userOpHash: transfer.userOpHash
-            }
-          });
-        }
-        submitted = {
-          txHash: transfer.txHash,
-          userOpHash: transfer.userOpHash
-        };
-        await config._data.mutation(api.payments.mutations.recordSubmitted, {
-          paymentId: created.id,
-          txHash: transfer.txHash,
-          userOpHash: transfer.userOpHash,
-          source: "sdk"
-        });
-        return [null, created];
-      } catch (cause) {
-        const error = mapCreateError(fromConvexError(cause));
-        if (created?.id && created.status === "processing" && !submitted) {
-          await bestEffortMarkFailed({ _data: config._data }, created.id, error);
-        }
-        if (submitted && created?.id) {
-          return [
-            new CapxulError({
-              code: "NETWORK_ERROR",
-              message: "Payment was submitted on-chain, but backend submission tracking failed.",
-              cause,
-              details: {
-                paymentId: created.id,
-                txHash: submitted.txHash,
-                userOpHash: submitted.userOpHash
-              }
-            }),
-            null
-          ];
-        }
-        return [error, null];
-      }
-    },
-    retrieve: async (paymentId) => {
-      if (!config._data) {
-        return stub("payments.retrieve");
-      }
-      try {
-        const payment = await config._data.query(
-          api.payments.queries.retrieve,
-          {
-            paymentId
-          }
-        );
-        if (!payment) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: `payment ${paymentId} not found`
-            }),
-            null
-          ];
-        }
-        return [null, payment];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub("payments.list");
-      }
-      try {
-        const page = await config._data.query(api.payments.queries.list, {
-          limit: input?.limit,
-          cursor: input?.cursor
-        });
-        return [null, page];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    }
-  };
-}
-function createOrgPaymentsClient() {
-  return {
-    create: async () => stub(
-      "organizations.payments.create"
-    ),
-    retrieve: async () => stub("organizations.payments.retrieve"),
-    list: async () => stub("organizations.payments.list")
-  };
-}
-async function bestEffortMarkFailed(config, paymentId, error) {
-  try {
-    await config._data.mutation(api.payments.mutations.markFailed, {
-      paymentId,
-      errorCode: error.code,
-      errorMessage: error.message,
-      source: "sdk"
-    });
-  } catch {
-  }
-}
-function mapCreateError(error) {
-  switch (error.code) {
-    case "NOT_AUTHENTICATED":
-    case "PERMISSION_DENIED":
-    case "INVALID_INPUT":
-    case "INVALID_RECIPIENT":
-    case "INSUFFICIENT_BALANCE":
-    case "IDEMPOTENCY_CONFLICT":
-    case "RATE_LIMITED":
-    case "NETWORK_ERROR":
-      return error;
-    default:
-      return new CapxulError({
-        code: "NETWORK_ERROR",
-        message: error.message,
-        cause: error,
-        details: error.details,
-        operationId: error.operationId,
-        correlationId: error.correlationId,
-        retryable: error.retryable
-      });
-  }
-}
-
-// src/core/transfers.ts
-function createTransfersClient() {
-  return {
-    create: async () => stub("transfers.create"),
-    retrieve: async () => stub("transfers.retrieve"),
-    list: async () => stub("transfers.list"),
-    confirm: async () => stub("transfers.confirm"),
-    cancel: async () => stub("transfers.cancel")
-  };
-}
-function createOrgTransfersClient() {
-  return {
-    create: async () => stub(
-      "organizations.transfers.create"
-    ),
-    retrieve: async () => stub("organizations.transfers.retrieve"),
-    list: async () => stub("organizations.transfers.list"),
-    confirm: async () => stub("organizations.transfers.confirm"),
-    cancel: async () => stub("organizations.transfers.cancel")
-  };
-}
-function createWithdrawalsClient(config = {}) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub("withdrawals.create");
-      }
-      const [createErr, createdRaw] = await tryCatch(
-        config._data.mutation(api.withdrawals.mutations.create, {
-          amount: input.amount,
-          destination: {
-            externalAccountId: input.destination.externalAccountId
-          },
-          source: input.source,
-          reference: input.reference,
-          idempotencyKey: input.idempotencyKey
-        })
-      );
-      if (createErr) {
-        return [mapCreateError2(fromConvexError(createErr)), null];
-      }
-      const created = createdRaw;
-      if (!created) {
-        return [
-          new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "withdrawals.create returned no withdrawal resource"
-          }),
-          null
-        ];
-      }
-      if (created.status !== "processing" || created.operation.status !== "processing") {
-        return [null, created];
-      }
-      if (!config.signer || !config.signing) {
-        return [null, created];
-      }
-      const [signerErr, currentSigner] = await tryCatch(
-        config._data.query(api.safe.queries.getMySignerAddress, {})
-      );
-      if (signerErr) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          mapCreateError2(fromConvexError(signerErr))
-        );
-      }
-      if (!currentSigner?.address) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          new CapxulError({
-            code: "PERMISSION_DENIED",
-            message: "No signer is registered for the authenticated account.",
-            details: { withdrawalId: created.id }
-          })
-        );
-      }
-      if (getAddress(currentSigner.address) !== getAddress(config.signer.address)) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          new CapxulError({
-            code: "PERMISSION_DENIED",
-            message: "Configured signer does not match the authenticated account signer.",
-            details: {
-              withdrawalId: created.id,
-              expectedSignerAddress: currentSigner.address,
-              actualSignerAddress: config.signer.address
-            }
-          })
-        );
-      }
-      const [prepErr, submission] = await tryCatch(
-        config._data.query(api.withdrawals.queries.prepareSubmission, {
-          withdrawalId: created.id
-        })
-      );
-      if (prepErr) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          mapCreateError2(fromConvexError(prepErr))
-        );
-      }
-      const destinationAddress = submission?.destinationAddress;
-      if (!submission || !destinationAddress) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "withdrawals.prepareSubmission returned no destination.",
-            details: { withdrawalId: created.id }
-          })
-        );
-      }
-      const token = resolvePaymentToken(submission.amount.currency);
-      const [transferErr, transferOk] = await tryCatch(
-        transferAsOwner(
-          {
-            signer: config.signer,
-            signing: config.signing
-          },
-          {
-            tokenAddress: token.address,
-            recipientAddress: destinationAddress,
-            amount: toTokenUnits(submission.amount.value, token.decimals)
-          }
-        )
-      );
-      if (transferErr) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          mapCreateError2(fromConvexError(transferErr))
-        );
-      }
-      if (!transferOk.success) {
-        return await handleSubmissionFailure(
-          { _data: config._data },
-          created.id,
-          new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "Bundler submission did not succeed.",
-            details: {
-              withdrawalId: created.id,
-              txHash: transferOk.txHash,
-              userOpHash: transferOk.userOpHash
-            }
-          })
-        );
-      }
-      const [recordErr] = await tryCatch(
-        config._data.mutation(api.withdrawals.mutations.recordSubmitted, {
-          withdrawalId: created.id,
-          txHash: transferOk.txHash,
-          userOpHash: transferOk.userOpHash
-        })
-      );
-      if (recordErr) {
-        return [
-          new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "Withdrawal was submitted on-chain, but backend submission tracking failed.",
-            cause: recordErr,
-            details: {
-              withdrawalId: created.id,
-              txHash: transferOk.txHash,
-              userOpHash: transferOk.userOpHash
-            }
-          }),
-          null
-        ];
-      }
-      return [null, created];
-    },
-    retrieve: async (withdrawalId) => {
-      if (!config._data) {
-        return stub("withdrawals.retrieve");
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.withdrawals.queries.retrieve, { withdrawalId })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      const withdrawal = raw;
-      if (!withdrawal) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `withdrawal ${withdrawalId} not found`
-          }),
-          null
-        ];
-      }
-      return [null, withdrawal];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub("withdrawals.list");
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.withdrawals.queries.list, {
-          limit: input?.limit,
-          cursor: input?.cursor
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      return [null, raw];
-    },
-    recordCompleted: async (input) => {
-      if (!config._data) {
-        return stub(
-          "withdrawals.recordCompleted"
-        );
-      }
-      const [err] = await tryCatch(
-        config._data.mutation(api.withdrawals.mutations.recordCompleted, {
-          withdrawalId: input.withdrawalId,
-          txHash: input.txHash
-        })
-      );
-      if (err) {
-        return [
-          mapRecordCompletedError(fromConvexError(err)),
-          null
-        ];
-      }
-      return [null, null];
-    }
-  };
-}
-function createOrgWithdrawalsClient(config = {}) {
-  return {
-    /**
-     * Org-scope create (Withdrawals v1 W2, #465).
-     *
-     * D6 — returns the `processing` row only. No `transferAsOwner`
-     * tail, no `recordSubmitted` call. Org Safe + Zodiac submission
-     * orchestration ships in W3+.
-     */
-    create: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.withdrawals.create"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.withdrawals.mutations.createOrg, {
-          organizationId: input.organizationId,
-          amount: input.amount,
-          destination: {
-            externalAccountId: input.destination.externalAccountId
-          },
-          source: input.source,
-          reference: input.reference,
-          idempotencyKey: input.idempotencyKey
-        })
-      );
-      if (err) {
-        return [mapCreateError2(fromConvexError(err)), null];
-      }
-      const created = raw;
-      if (!created) {
-        return [
-          new CapxulError({
-            code: "NETWORK_ERROR",
-            message: "organizations.withdrawals.create returned no withdrawal resource"
-          }),
-          null
-        ];
-      }
-      return [null, created];
-    },
-    retrieve: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.withdrawals.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.withdrawals.queries.retrieve, {
-          withdrawalId: input.withdrawalId
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      const withdrawal = raw;
-      if (!withdrawal) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `withdrawal ${input.withdrawalId} not found`
-          }),
-          null
-        ];
-      }
-      const ownerCheck = withdrawal.owner;
-      if (ownerCheck?.type !== "organization" || ownerCheck.id !== input.organizationId) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `withdrawal ${input.withdrawalId} does not belong to organization ${input.organizationId}`
-          }),
-          null
-        ];
-      }
-      return [null, withdrawal];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.withdrawals.list"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.withdrawals.queries.listOrg, {
-          organizationId: input.organizationId,
-          limit: input.limit,
-          cursor: input.cursor
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      return [null, raw];
-    }
-  };
-}
-async function handleSubmissionFailure(config, withdrawalId, error) {
-  await bestEffortMarkFailed2(config, withdrawalId, error);
-  return [error, null];
-}
-async function bestEffortMarkFailed2(config, withdrawalId, error) {
-  await tryCatch(
-    config._data.mutation(api.withdrawals.mutations.markFailed, {
-      withdrawalId,
-      errorCode: error.code,
-      errorMessage: error.message
-    })
-  );
-}
-function mapCreateError2(error) {
-  switch (error.code) {
-    case "NOT_AUTHENTICATED":
-    case "PERMISSION_DENIED":
-    case "INVALID_INPUT":
-    case "INSUFFICIENT_BALANCE":
-    case "IDEMPOTENCY_CONFLICT":
-    case "KYC_REQUIRED":
-    case "POLICY_DENIED":
-    case "RATE_LIMITED":
-    case "NETWORK_ERROR":
-    case "NOT_FOUND":
-    case "VERIFICATION_REQUIRED":
-      return error;
-    default:
-      return new CapxulError({
-        code: "NETWORK_ERROR",
-        message: error.message,
-        cause: error,
-        details: error.details,
-        operationId: error.operationId,
-        correlationId: error.correlationId,
-        retryable: error.retryable
-      });
-  }
-}
-function mapRecordCompletedError(error) {
-  switch (error.code) {
-    case "NOT_AUTHENTICATED":
-    case "PERMISSION_DENIED":
-    case "INVALID_INPUT":
-    case "NOT_FOUND":
-    case "NETWORK_ERROR":
-    case "INTERNAL_ERROR":
-      return error;
-    default:
-      return new CapxulError({
-        code: "NETWORK_ERROR",
-        message: error.message,
-        cause: error,
-        details: error.details,
-        operationId: error.operationId,
-        correlationId: error.correlationId,
-        retryable: error.retryable
-      });
-  }
-}
-
-// src/core/webhook-endpoints.ts
-function createWebhookEndpointsClient() {
-  return {
-    create: async () => stub(
-      "webhookEndpoints.create"
-    ),
-    retrieve: async () => stub("webhookEndpoints.retrieve"),
-    list: async () => stub("webhookEndpoints.list"),
-    remove: async () => stub("webhookEndpoints.remove")
-  };
-}
-
-// src/core/webhook-events.ts
-function createWebhookEventsClient() {
-  return {
-    retrieve: async () => stub("webhookEvents.retrieve"),
-    list: async () => stub("webhookEvents.list")
-  };
-}
-
-// src/core/organizations.ts
-function createOrgExternalAccountsClient(config) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.externalAccounts.create"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.externalAccounts.mutations.createOrg, {
-          organizationId: input.organizationId,
-          kind: input.kind,
-          label: input.label,
-          address: input.address,
-          iban: input.iban,
-          bic: input.bic,
-          accountHolder: input.accountHolder,
-          network: input.network,
-          panToken: input.panToken,
-          last4: input.last4
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: "external_account creation returned no resource"
-          }),
-          null
-        ];
-      }
-      return [null, brandExternalAccount(raw)];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.externalAccounts.list"
-        );
-      }
-      const [err, result] = await tryCatch(
-        config._data.query(api.externalAccounts.queries.listOrg, {
-          organizationId: input.organizationId,
-          limit: input.limit,
-          cursor: input.cursor
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      const branded = result.data.map(
-        (row) => brandExternalAccount(row)
-      );
-      return [
-        null,
-        {
-          object: "list",
-          data: branded,
-          page: result.page
-        }
-      ];
-    },
-    retrieve: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.externalAccounts.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.externalAccounts.queries.retrieveOrg, {
-          organizationId: input.organizationId,
-          externalAccountId: input.externalAccountId
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `external_account ${input.externalAccountId} not found`
-          }),
-          null
-        ];
-      }
-      return [null, brandExternalAccount(raw)];
-    },
-    remove: async (input) => {
-      if (!config._data) {
-        return stub("organizations.externalAccounts.remove");
-      }
-      const [err] = await tryCatch(
-        config._data.mutation(api.externalAccounts.mutations.removeOrg, {
-          organizationId: input.organizationId,
-          externalAccountId: input.externalAccountId
-        })
-      );
-      if (err) {
-        return [fromConvexError(err), null];
-      }
-      return [null, void 0];
-    }
-  };
-}
-function createOrgSubAccountsClient(config) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.subAccounts.create"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.subAccounts.mutations.create, {
-          parent: {
-            kind: "organization",
-            id: input.organizationId
-          },
-          name: input.name,
-          purpose: input.purpose
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: "sub_account creation returned no resource"
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [brandErr, null];
-      }
-      return [null, branded];
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.subAccounts.list"
-        );
-      }
-      const [err, rows] = await tryCatch(
-        config._data.query(api.subAccounts.queries.listByOrganization, {
-          organizationId: input.organizationId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      const branded = [];
-      for (const row of rows) {
-        const [brandErr, value] = tryBrandSubAccount(row);
-        if (brandErr) {
-          return [brandErr, null];
-        }
-        branded.push(value);
-      }
-      return [
-        null,
-        {
-          object: "list",
-          data: branded,
-          page: { hasMore: false }
-        }
-      ];
-    },
-    retrieve: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.subAccounts.retrieve"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.query(api.subAccounts.queries.retrieve, {
-          subAccountId: input.subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${input.subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [
-          brandErr,
-          null
-        ];
-      }
-      return [null, branded];
-    },
-    remove: async (input) => {
-      if (!config._data) {
-        return stub(
-          "organizations.subAccounts.remove"
-        );
-      }
-      const [err, raw] = await tryCatch(
-        config._data.mutation(api.subAccounts.mutations.archive, {
-          subAccountId: input.subAccountId
-        })
-      );
-      if (err) {
-        return [
-          fromConvexError(err),
-          null
-        ];
-      }
-      if (!raw) {
-        return [
-          new CapxulError({
-            code: "NOT_FOUND",
-            message: `sub_account ${input.subAccountId} not found`
-          }),
-          null
-        ];
-      }
-      const [brandErr, branded] = tryBrandSubAccount(raw);
-      if (brandErr) {
-        return [
-          brandErr,
-          null
-        ];
-      }
-      return [null, branded];
-    }
-  };
-}
-function createOrganizationsClient(config = {}) {
-  return {
-    create: async (input) => {
-      if (!config._data) {
-        return stub("organizations.create");
-      }
-      if (input.country !== void 0) {
-        return [
-          new CapxulError({
-            code: "INVALID_INPUT",
-            message: "organizations.create does not support country yet \u2014 backend mutation only accepts name.",
-            details: { field: "country" }
-          }),
-          null
-        ];
-      }
-      try {
-        const orgId = await config._data.mutation(api.org.mutations.create, {
-          name: input.name
-        });
-        const org = await config._data.query(api.org.queries.retrieve, {
-          orgId
-        });
-        if (!org) {
-          return [
-            new CapxulError({
-              code: "NETWORK_ERROR",
-              message: "organization created but could not be retrieved"
-            }),
-            null
-          ];
-        }
-        return [null, org];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    retrieve: async (organizationId) => {
-      if (!config._data) {
-        return stub("organizations.retrieve");
-      }
-      try {
-        const orgId = organizationId.replace(/^org_/, "");
-        const org = await config._data.query(api.org.queries.retrieve, {
-          orgId
-        });
-        if (!org) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: `organization ${organizationId} not found`
-            }),
-            null
-          ];
-        }
-        return [null, org];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    list: async (input) => {
-      if (!config._data) {
-        return stub("organizations.list");
-      }
-      try {
-        const page = await config._data.query(api.org.queries.list, {
-          limit: input?.limit,
-          cursor: input?.cursor
-        });
-        const result = {
-          object: "list",
-          data: page.data,
-          page: {
-            hasMore: page.hasMore,
-            cursor: page.nextCursor
-          }
-        };
-        return [null, result];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    update: async (input) => {
-      if (!config._data) {
-        return stub("organizations.update");
-      }
-      try {
-        const orgId = input.organizationId.replace(/^org_/, "");
-        const org = await config._data.mutation(api.org.mutations.update, {
-          orgId,
-          name: input.name
-        });
-        if (!org) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: `organization ${input.organizationId} not found`
-            }),
-            null
-          ];
-        }
-        return [null, org];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    safes: {
-      retrieve: async (input) => {
-        if (!config._data) {
-          return stub("organizations.safes.retrieve");
-        }
-        try {
-          const safe = await config._data.query(
-            api.safe.queries.retrieveOrganizationSafe,
-            input
-          );
-          if (!safe) {
-            return [
-              new CapxulError({
-                code: "NOT_FOUND",
-                message: `safe ${input.safeId} not found`
-              }),
-              null
-            ];
-          }
-          return [null, safe];
-        } catch (cause) {
-          return [
-            fromConvexError(cause),
-            null
-          ];
-        }
-      }
-    },
-    treasury: {
-      retrieve: async (organizationId) => {
-        if (!config._data) {
-          return stub(
-            "organizations.treasury.retrieve"
-          );
-        }
-        try {
-          const orgId = organizationId.replace(/^org_/, "");
-          const raw = await config._data.query(
-            api.safe.queries.getOrgTreasuryBalance,
-            { orgId }
-          );
-          if (!raw) {
-            return [
-              new CapxulError({
-                code: "NOT_FOUND",
-                message: `treasury for organization ${organizationId} not found`
-              }),
-              null
-            ];
-          }
-          const treasury = {
-            object: "treasury",
-            id: toTreasuryId(`try_${orgId}`),
-            organizationId,
-            status: "active",
-            safeId: toSafeId(
-              `safe_${raw.safeAddress.replace(/^0x/, "").toLowerCase()}`
-            ),
-            totalBalance: { value: "0", currency: "USD" },
-            positions: raw.tokens.map((t) => ({
-              symbol: t.symbol,
-              contractAddress: t.tokenAddress,
-              amount: t.balance
-            })),
-            asOf: raw.lastUpdatedAt ? new Date(raw.lastUpdatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
-          };
-          return [null, treasury];
-        } catch (cause) {
-          return [
-            fromConvexError(cause),
-            null
-          ];
-        }
-      }
-    },
-    members: {
-      list: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.list");
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const page = await config._data.action(api.org.actions.membersList, {
-            organizationId: orgId,
-            status: input.status,
-            limit: input.limit,
-            cursor: input.cursor
-          });
-          return [null, page];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      retrieve: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.retrieve");
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const memberId = input.memberId.replace(/^mb_/, "");
-          const member = await config._data.action(
-            api.org.actions.retrieveMember,
-            {
-              organizationId: orgId,
-              memberId
-            }
-          );
-          return [null, member];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      invite: async (input) => {
-        if (!config._data?.action) {
-          return stub(
-            "organizations.members.invite"
-          );
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const result = await config._data.action(
-            api.org.actions.inviteMember,
-            {
-              organizationId: orgId,
-              email: input.email,
-              role: input.role
-            }
-          );
-          return [null, result];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      accept: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.accept");
-        }
-        try {
-          const member = await config._data.action(
-            api.org.actions.acceptInvitation,
-            { token: input.token }
-          );
-          return [null, member];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      updateRole: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.updateRole");
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const memberId = input.memberId.replace(/^mb_/, "");
-          const member = await config._data.action(
-            api.org.actions.updateMemberRole,
-            {
-              organizationId: orgId,
-              memberId,
-              role: input.role
-            }
-          );
-          return [null, member];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      revoke: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.revoke");
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const memberId = input.memberId.replace(/^mb_/, "");
-          const member = await config._data.action(
-            api.org.actions.revokeMember,
-            {
-              organizationId: orgId,
-              memberId
-            }
-          );
-          return [null, member];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      remove: async (input) => {
-        if (!config._data?.action) {
-          return stub("organizations.members.remove");
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const memberId = input.memberId.replace(/^mb_/, "");
-          await config._data.action(api.org.actions.removeMember, {
-            organizationId: orgId,
-            memberId
-          });
-          return [null, void 0];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      resend: async (input) => {
-        if (!config._data?.action) {
-          return stub(
-            "organizations.members.resend"
-          );
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const memberId = input.memberId.replace(/^mb_/, "");
-          const result = await config._data.action(
-            api.org.actions.resendInvitation,
-            {
-              organizationId: orgId,
-              memberId
-            }
-          );
-          return [null, result];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      }
-    },
-    apiKeys: createApiKeysClient(),
-    subAccounts: createOrgSubAccountsClient(config),
-    externalAccounts: createOrgExternalAccountsClient(config),
-    balanceLedger: {
-      list: async (input) => {
-        if (!config._data) {
-          return stub(
-            "organizations.balanceLedger.list"
-          );
-        }
-        try {
-          const orgId = input.organizationId.replace(/^org_/, "");
-          const page = await config._data.query(
-            api.balanceLedger.queries.listForOrg,
-            { orgId, limit: input.limit, cursor: input.cursor }
-          );
-          return [null, page];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      },
-      retrieve: async (input) => {
-        if (!config._data) {
-          return stub(
-            "organizations.balanceLedger.retrieve"
-          );
-        }
-        try {
-          const entry = await config._data.query(
-            api.balanceLedger.queries.retrieve,
-            { entryId: input.entryId }
-          );
-          if (!entry) {
-            return [
-              new CapxulError({
-                code: "NOT_FOUND",
-                message: `balance_ledger_entry ${input.entryId} not found`
-              }),
-              null
-            ];
-          }
-          return [null, entry];
-        } catch (cause) {
-          return [fromConvexError(cause), null];
-        }
-      }
-    },
-    payments: createOrgPaymentsClient(),
-    transfers: createOrgTransfersClient(),
-    withdrawals: createOrgWithdrawalsClient(config),
-    documents: createOrgDocumentsClient(config),
-    webhookEndpoints: createWebhookEndpointsClient(),
-    webhookEvents: createWebhookEventsClient()
-  };
-}
-
-// src/core/token-transfers.ts
-var toTokenTransferId = (raw) => {
-  if (typeof raw !== "string" || raw.length === 0) {
-    throw new Error(
-      `Invalid tokenTransferId: expected non-empty string, got ${String(raw)}`
-    );
-  }
-  return raw;
-};
-function brandRow(row) {
-  return {
-    ...row,
-    id: toTokenTransferId(row.id)
-  };
-}
-function createTokenTransfersClient(config = {}) {
-  return {
-    list: async (input) => {
-      if (!config._data) {
-        return stub("tokenTransfers.list");
-      }
-      try {
-        const raw = await config._data.query(
-          api.tokenTransfers.queries.list,
-          {
-            limit: input?.limit,
-            cursor: input?.cursor,
-            direction: input?.direction
-          }
-        );
-        if (!raw) {
-          return [
-            new CapxulError({
-              code: "NOT_AUTHENTICATED",
-              message: "tokenTransfers.list requires an authenticated session."
-            }),
-            null
-          ];
-        }
-        return [
-          null,
-          {
-            object: "list",
-            data: raw.items.map(brandRow),
-            page: {
-              hasMore: raw.hasMore,
-              nextCursor: raw.nextCursor
-            },
-            displayCurrency: raw.displayCurrency
-          }
-        ];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    },
-    retrieve: async (input) => {
-      if (!config._data) {
-        return stub("tokenTransfers.retrieve");
-      }
-      try {
-        const raw = await config._data.query(
-          api.tokenTransfers.queries.getByTxLogIndex,
-          {
-            txHash: input.txHash,
-            logIndex: input.logIndex,
-            chainId: input.chainId
-          }
-        );
-        if (!raw) {
-          return [
-            new CapxulError({
-              code: "NOT_FOUND",
-              message: `tokenTransfer (txHash=${input.txHash}, logIndex=${input.logIndex}) not found or not visible to caller.`,
-              details: {
-                txHash: input.txHash,
-                logIndex: input.logIndex,
-                chainId: input.chainId
-              }
-            }),
-            null
-          ];
-        }
-        return [null, brandRow(raw)];
-      } catch (cause) {
-        return [fromConvexError(cause), null];
-      }
-    }
-  };
-}
-
-// src/core/virtual-accounts.ts
-function createVirtualAccountsClient() {
-  return {
-    create: async () => stub("virtualAccounts.create"),
-    retrieve: async () => stub("virtualAccounts.retrieve"),
-    list: async () => stub("virtualAccounts.list"),
-    remove: async () => stub("virtualAccounts.remove")
-  };
-}
-
-// src/core/virtual-cards.ts
-function createVirtualCardsClient() {
-  return {
-    create: async () => stub("virtualCards.create"),
-    retrieve: async () => stub("virtualCards.retrieve"),
-    list: async () => stub("virtualCards.list"),
-    freeze: async () => stub("virtualCards.freeze"),
-    unfreeze: async () => stub("virtualCards.unfreeze"),
-    cancel: async () => stub("virtualCards.cancel")
-  };
-}
-function createProvisioningMachine(client) {
-  return setup({
-    types: {},
-    actors: {
-      provisionPersonal: fromPromise(async ({ input }) => {
-        const [error, account] = await client.accounts.provisionPersonal(
-          input.input
-        );
-        if (error) throw error;
-        return account;
-      })
-    },
-    guards: {
-      hasInput: ({ context }) => context.input !== null
-    },
-    actions: {
-      trackWalletCreated: ({ context }) => {
-        const provider = context.input?.signerProvider;
-        if (!provider) return;
-        track("provisioning_wallet_created", {
-          eoa_address: provider.signerAddress
-        });
-      },
-      trackSafeCreated: ({ context }) => {
-        const provider = context.input?.signerProvider;
-        if (!provider) return;
-        track("provisioning_safe_created", {
-          safe_address: deriveSafeAddress2(provider.signerAddress)
-        });
-      }
-    }
-  }).createMachine({
-    id: "provisioning",
-    initial: "starting",
-    context: ({ input }) => ({
-      input: input?.input ?? null,
-      account: null,
-      error: null
-    }),
-    states: {
-      // Transient routing state: skip `idle` when input was provided
-      // at creation time (the invoked-by-parent path).
-      starting: {
-        always: [
-          { guard: "hasInput", target: "running" },
-          { target: "idle" }
-        ]
-      },
-      idle: {
-        on: {
-          START: {
-            target: "running",
-            actions: assign({
-              input: ({ event }) => event.input,
-              account: () => null,
-              error: () => null
-            })
-          }
-        }
-      },
-      running: {
-        invoke: {
-          src: "provisionPersonal",
-          input: ({ context }) => ({
-            input: requireProvisionInput(context)
-          }),
-          onDone: {
-            target: "done",
-            actions: assign({ account: ({ event }) => event.output })
-          },
-          onError: {
-            target: "error",
-            actions: assign({ error: ({ event }) => errorFromEvent(event) })
-          }
-        },
-        after: {
-          [FLOW_INVOKE_TIMEOUT_MS]: {
-            target: "error",
-            actions: assign({ error: () => timeoutError() })
-          }
-        }
-      },
-      done: {
-        type: "final",
-        entry: ["trackWalletCreated", "trackSafeCreated"]
-      },
-      error: {
-        type: "final"
-      }
-    },
-    /**
-     * Root-level output mapper — fires when the machine reaches any
-     * top-level `final` state (`done` or `error`). The parent receives
-     * this payload on its `onDone` transition and branches via guards
-     * on `event.output.error`.
-     */
-    output: ({ context }) => context.error ? { error: context.error } : context.account ? { account: context.account } : { error: timeoutError() }
-  });
-}
-function requireProvisionInput(context) {
-  if (!context.input) {
-    throw Errors.invalidInput(
-      "input",
-      "Provisioning flow advanced to running without input captured in context."
-    );
-  }
-  return context.input;
-}
-function errorFromEvent(event) {
-  const cause = typeof event === "object" && event !== null && "error" in event ? event.error : event;
-  if (cause instanceof CapxulError) return cause;
-  if (cause instanceof CapxulError2) return cause;
-  return Errors.providerError("provisioning", "flow", cause);
-}
-function timeoutError() {
-  return Errors.providerError(
-    "provisioning",
-    "flow",
-    new Error(`timeout: running exceeded ${FLOW_INVOKE_TIMEOUT_MS}ms`)
-  );
-}
-
-// src/flows/onboarding.ts
-function createOnboardingFlowMachine(client) {
-  const provisioningMachine = createProvisioningMachine(client);
-  return setup({
-    types: {},
-    actors: {
-      provisioningMachine
-    },
-    guards: {
-      isOrg: ({ event }) => event.type === "START_PROVISIONING" && event.input.kind !== "account",
-      missingSigner: ({ event }) => event.type === "START_PROVISIONING" && event.input.kind === "account" && !event.input.signerProvider,
-      childReportedError: ({ event }) => {
-        if (typeof event !== "object" || event === null || !("output" in event)) {
-          return false;
-        }
-        const output = event.output;
-        return typeof output === "object" && output !== null && "error" in output && output.error != null;
-      }
-    },
-    actions: {
-      // Always-on for any START_PROVISIONING transition.
-      assignOperationIdAndInput: assign({
-        operationId: () => generateOperationId(),
-        input: ({ event }) => event.type === "START_PROVISIONING" ? event.input : null,
-        error: () => null,
-        account: () => null
-      }),
-      // Pre-actor rejection branches stamp the synchronous error.
-      assignOrgNotImplemented: assign({
-        error: () => new CapxulError({
-          code: "NOT_IMPLEMENTED",
-          message: "useOnboardingFlow organization onboarding is not implemented in this local-private-key slice."
-        })
-      }),
-      assignMissingSigner: assign({
-        error: () => new CapxulError({
-          code: "INVALID_INPUT",
-          message: "useOnboardingFlow requires a signerProvider for account onboarding."
-        })
-      }),
-      // Telemetry actions — order matters; the source fires the
-      // "submitted" track BEFORE the rejection track on validation
-      // errors, and the happy path follows the documented sequence.
-      trackOrgSubmitted: ({ event }) => {
-        if (event.type !== "START_PROVISIONING") return;
-        track("onboarding_org_submitted", {
-          country: event.input.country ?? "unknown"
-        });
-      },
-      trackPersonalSubmitted: ({ event }) => {
-        if (event.type !== "START_PROVISIONING") return;
-        track("onboarding_personal_submitted", {
-          country: event.input.country ?? "unknown",
-          wallet_count: event.input.signerProvider ? 1 : 0
-        });
-      },
-      trackOrgNotImplementedError: () => {
-        track("onboarding_wallet_error", {
-          step: "profile",
-          reason: "organization_not_implemented"
-        });
-      },
-      trackMissingSignerError: () => {
-        track("onboarding_wallet_error", {
-          step: "profile",
-          reason: "missing_signer_provider"
-        });
-      },
-      trackWalletCreating: () => {
-        track("onboarding_wallet_creating");
-      },
-      trackOnboardingCompleted: () => {
-        track("onboarding_completed", { account_type: "personal" });
-      },
-      trackProvisioningFailed: ({ context }) => {
-        const code = context.error?.code ?? "UNKNOWN";
-        track("onboarding_wallet_error", {
-          step: "provision_personal",
-          reason: code
-        });
-      },
-      assignChildReportedError: assign({
-        error: ({ event }) => extractChildErrorOrFallback(event)
-      }),
-      assignChildThrown: assign({
-        error: ({ event }) => errorFromEvent2(event)
-      }),
-      assignAccountFromChild: assign({
-        account: ({ event }) => extractChildAccountOrNull(event)
-      }),
-      resetContext: assign({
-        input: () => null,
-        operationId: () => null,
-        account: () => null,
-        error: () => null
-      })
-    }
-  }).createMachine({
-    id: "onboarding",
-    initial: "profile",
-    context: {
-      input: null,
-      operationId: null,
-      account: null,
-      error: null
-    },
-    states: {
-      profile: {
-        on: {
-          START_PROVISIONING: [
-            {
-              guard: "isOrg",
-              target: "error",
-              actions: [
-                "assignOperationIdAndInput",
-                "trackOrgSubmitted",
-                "assignOrgNotImplemented",
-                "trackOrgNotImplementedError"
-              ]
-            },
-            {
-              guard: "missingSigner",
-              target: "error",
-              actions: [
-                "assignOperationIdAndInput",
-                "trackPersonalSubmitted",
-                "assignMissingSigner",
-                "trackMissingSignerError"
-              ]
-            },
-            {
-              target: "provisioning",
-              actions: [
-                "assignOperationIdAndInput",
-                "trackPersonalSubmitted"
-              ]
-            }
-          ]
-        }
-      },
-      provisioning: {
-        entry: ["trackWalletCreating"],
-        invoke: {
-          src: "provisioningMachine",
-          input: ({ context }) => ({
-            input: requireProvisionInput2(context)
-          }),
-          // The child machine reaches a top-level `final` state for
-          // both success and failure, so the parent's `onDone` fires
-          // in both cases. We branch via a guard on
-          // `event.output.error`. The child machine has its own
-          // `FLOW_INVOKE_TIMEOUT_MS` timer that ends in a final
-          // `error` state on timeout — that signal flows back through
-          // `onDone` + the `childReportedError` guard. The previous
-          // duplicate parent `after: FLOW_INVOKE_TIMEOUT_MS` was
-          // removed in PR #406 (X1+G3) so the child's `output.error`
-          // is the single source of provisioning failure.
-          onDone: [
-            {
-              guard: "childReportedError",
-              target: "error",
-              actions: [
-                "assignChildReportedError",
-                "trackProvisioningFailed"
-              ]
-            },
-            {
-              target: "complete",
-              actions: [
-                "assignAccountFromChild",
-                "trackOnboardingCompleted"
-              ]
-            }
-          ],
-          // `onError` is the safety net for an unexpected throw from
-          // inside the child machine itself (not the spawned actor's
-          // `error` final state, which goes through `onDone`). In
-          // normal flow this never fires.
-          onError: {
-            target: "error",
-            actions: ["assignChildThrown", "trackProvisioningFailed"]
-          }
-        }
-      },
-      // TODO(stack-1): wire `action_required` once the KYC gate /
-      // async-resume `NextAction` path is lifted from
-      // `useOperation(operationId)`. PROCEED → provisioning re-enters
-      // the actor with the resumed input. Currently unreachable from
-      // any transition; declared for parity with the public type.
-      action_required: {
-        on: {
-          PROCEED: { target: "provisioning" },
-          RESET: { target: "profile", actions: "resetContext" }
-        }
-      },
-      complete: {
-        on: {
-          RESET: { target: "profile", actions: "resetContext" }
-        }
-      },
-      error: {
-        on: {
-          RESET: { target: "profile", actions: "resetContext" }
-        }
-      }
-    }
-  });
-}
-function generateOperationId() {
-  return toOperationId(`op_onboarding_local_${Date.now().toString(36)}`);
-}
-function requireProvisionInput2(context) {
-  if (!context.input || !context.input.signerProvider) {
-    throw Errors.invalidInput(
-      "signerProvider",
-      "Onboarding flow advanced to provisioning without a signerProvider in context."
-    );
-  }
-  return {
-    displayName: context.input.displayName,
-    username: context.input.username,
-    countryCode: context.input.country,
-    signerProvider: context.input.signerProvider
-  };
-}
-function extractChildOutput(event) {
-  if (typeof event !== "object" || event === null || !("output" in event)) {
-    return null;
-  }
-  const output = event.output;
-  if (typeof output !== "object" || output === null) return null;
-  return output;
-}
-function extractChildErrorOrFallback(event) {
-  const output = extractChildOutput(event);
-  if (output && "error" in output && output.error) return output.error;
-  return Errors.providerError(
-    "onboarding",
-    "flow",
-    new Error("provisioning child reported error without payload")
-  );
-}
-function extractChildAccountOrNull(event) {
-  const output = extractChildOutput(event);
-  if (output && "account" in output && output.account) return output.account;
-  return null;
-}
-function errorFromEvent2(event) {
-  const cause = typeof event === "object" && event !== null && "error" in event ? event.error : event;
-  if (cause instanceof CapxulError) return cause;
-  if (cause instanceof CapxulError2) return cause;
-  return Errors.providerError("onboarding", "flow", cause);
-}
-
-// src/client.ts
-function createCapxulClient(config = {}) {
-  const clientWithoutFlows = {
-    id: crypto.randomUUID(),
-    auth: new AuthService(config),
-    me: createMeClient(config),
-    accounts: createAccountsClient(config),
-    organizations: createOrganizationsClient(config),
-    payments: createPaymentsClient(config),
-    transfers: createTransfersClient(),
-    tokenTransfers: createTokenTransfersClient(config),
-    withdrawals: createWithdrawalsClient(config),
-    documents: createDocumentsClient(config),
-    subAccounts: createSubAccountsClient(config),
-    virtualAccounts: createVirtualAccountsClient(),
-    virtualCards: createVirtualCardsClient(),
-    externalAccounts: createExternalAccountsClient(config),
-    operations: createOperationsClient(config),
-    webhookEndpoints: createWebhookEndpointsClient(),
-    webhookEvents: createWebhookEventsClient(),
-    apiKeys: createApiKeysClient()
-  };
-  const client = clientWithoutFlows;
-  client.flows = {
-    onboarding: () => createOnboardingFlowMachine(client),
-    provisioning: () => createProvisioningMachine(client)
-  };
-  return client;
-}
-
-// src/match.ts
-function matchError(err, handlers) {
-  const handler = handlers[err.code];
-  return handler(err);
-}
-function matchStatus(value, handlers) {
-  const handler = handlers[value.status];
-  return handler(value);
-}
-function matchAction(action, handlers) {
-  const handler = handlers[action.kind];
-  return handler(action);
-}
-function createLocalSigner(privateKey) {
-  return privateKeyToAccount(privateKey);
-}
-
-// src/webhooks.ts
-async function verifyWebhook(request, secret, options) {
-  if (!secret) {
-    throw new CapxulError({
-      code: "INVALID_INPUT",
-      message: "A webhook signing secret is required."
-    });
-  }
-  const timestamp = request.headers.get("x-capxul-timestamp");
-  const signature = request.headers.get("x-capxul-signature");
-  if (!timestamp || !signature) {
-    return { valid: false, reason: "invalid_signature" };
-  }
-  const timestampMs = Number(timestamp);
-  if (!Number.isFinite(timestampMs)) {
-    return { valid: false, reason: "malformed" };
-  }
-  const freshnessWindowMs = options?.freshnessWindowMs ?? WEBHOOK_FRESHNESS_WINDOW_MS;
-  if (Math.abs(Date.now() - timestampMs) > freshnessWindowMs) {
-    return { valid: false, reason: "replay" };
-  }
-  const body = await request.text();
-  const signatureHex = signature.startsWith("sha256=") ? signature.slice("sha256=".length) : signature;
-  if (!/^[a-f0-9]{64}$/i.test(signatureHex)) {
-    return { valid: false, reason: "invalid_signature" };
-  }
-  const validSignature = await verifyHmacSha256(
-    secret,
-    `${timestamp}.${body}`,
-    signatureHex
-  );
-  if (!validSignature) {
-    return { valid: false, reason: "invalid_signature" };
-  }
-  const parsed = parseWebhookEvent(body);
-  if (!parsed) {
-    return { valid: false, reason: "malformed" };
-  }
-  return { valid: true, event: parsed };
-}
-async function verifyHmacSha256(secret, message, signatureHex) {
-  const encoder = new TextEncoder();
-  const key = await crypto.subtle.importKey(
-    "raw",
-    encoder.encode(secret),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["verify"]
-  );
-  return await crypto.subtle.verify(
-    "HMAC",
-    key,
-    hexToArrayBuffer(signatureHex),
-    encoder.encode(message)
-  );
-}
-function hexToArrayBuffer(hex) {
-  const buffer = new ArrayBuffer(hex.length / 2);
-  const bytes = new Uint8Array(buffer);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return buffer;
-}
-function parseWebhookEvent(body) {
-  try {
-    const parsed = JSON.parse(body);
-    if (!isWebhookEvent(parsed)) return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isWebhookEvent(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.id === "string" && typeof candidate.type === "string" && typeof candidate.createdAt === "string" && (candidate.operationId === void 0 || typeof candidate.operationId === "string") && (candidate.correlationId === void 0 || typeof candidate.correlationId === "string") && !!candidate.data && typeof candidate.data === "object" && !Array.isArray(candidate.data);
-}
-var SignerProvisioner = class {
-  provision() {
-    const privateKey = generatePrivateKey();
-    const signer = privateKeyToAccount(privateKey);
-    const safeAddress = deriveSafeAddress2(signer.address);
-    return { signer, safeAddress };
-  }
-};
-
-export { AuthService, CapxulError, SignerProvisioner, createCapxulClient, createLocalSigner, createOnboardingFlowMachine, createProvisioningMachine as createProvisioningFlowMachine, makeHttpTransport, matchAction, matchError, matchStatus, resolvePaymentToken, toAccountId, toApiKeyId, toBalanceLedgerEntryId, toDocumentId, toEmail, toExternalAccountId, toKybProfileId, toKycProfileId, toMemberId, toOperationId, toOrganizationId, toPaymentId, toPhoneNumber, toSafeId, toSubAccountId, toTokenTransferId, toTransferId, toTreasuryId, toUsername, toVirtualAccountId, toVirtualCardId, toWebhookEndpointId, toWebhookEventId, toWithdrawalId, tryCatch, verifyWebhook };