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

package/dist/client.js

@@ -1,4040 +0,0 @@
-import { componentsGeneric, anyApi } from 'convex/server';
-import { toSafeSmartAccount } from 'permissionless/accounts';
-import { getAddress, parseUnits, encodeFunctionData, encodePacked, keccak256, getContractAddress, 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';
-
-// 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;
-
-// ../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 toSafeId = makePrefixedIdConstructor(
-  "safe",
-  "safeId"
-);
-var toTreasuryId = makePrefixedIdConstructor(
-  "try",
-  "treasuryId"
-);
-var toOperationId = makePrefixedIdConstructor(
-  "op",
-  "operationId"
-);
-var toCorrelationId = makePrefixedIdConstructor("ctx", "correlationId");
-var toExternalAccountId = makePrefixedIdConstructor("ext", "externalAccountId");
-var toSubAccountId = makePrefixedIdConstructor(
-  "sub",
-  "subAccountId"
-);
-
-// 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;
-}
-
-export { createCapxulClient };