@bandeira-tech/b3nd-web 0.2.3 → 0.2.5

package/dist/{chunk-K3ZSSVHR.js → chunk-JN75UL5C.js}

@@ -585,6 +585,8 @@ async function createSignedSymmetricMessage(data, signers, keyHex) {
 }
 
 export {
+  encodeHex,
+  decodeHex,
   IdentityKey,
   PublicEncryptionKey,
   SecretEncryptionKey,

package/dist/clients/memory/mod.d.ts

@@ -0,0 +1,25 @@
+import { S as Schema, N as NodeProtocolInterface, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, H as HealthStatus, D as DeleteResult } from '../../types-oQCx3U-_.js';
+
+type MemoryClientStorageNode<T> = {
+    value?: T;
+    children?: Map<string, MemoryClientStorageNode<unknown>>;
+};
+type MemoryClientStorage = Map<string, MemoryClientStorageNode<unknown>>;
+interface MemoryClientConfig {
+    schema: Schema;
+    storage?: MemoryClientStorage;
+}
+declare class MemoryClient implements NodeProtocolInterface {
+    protected storage: MemoryClientStorage;
+    protected schema: Schema;
+    constructor(config: MemoryClientConfig);
+    write<T = unknown>(uri: string, payload: T): Promise<WriteResult<T>>;
+    read<T>(uri: string): Promise<ReadResult<T>>;
+    list(uri: string, options?: ListOptions): Promise<ListResult>;
+    health(): Promise<HealthStatus>;
+    getSchema(): Promise<string[]>;
+    cleanup(): Promise<void>;
+    delete(uri: string): Promise<DeleteResult>;
+}
+
+export { MemoryClient, type MemoryClientConfig };

package/dist/clients/memory/mod.js

@@ -0,0 +1,203 @@
+import "../../chunk-MLKGABMK.js";
+
+// clients/memory/mod.ts
+function target(uri, schema, storage) {
+  const url = URL.parse(uri);
+  const program = `${url.protocol}//${url.hostname}`;
+  if (!schema[program]) {
+    return { success: false, error: "Program not found" };
+  }
+  const node = storage.get(program);
+  if (!node) {
+    return { success: false, error: "Storage not initialized for program" };
+  }
+  const parts = url.pathname.substring(1).split("/");
+  return {
+    success: true,
+    program,
+    path: url.pathname,
+    node,
+    parts
+  };
+}
+var MemoryClient = class {
+  constructor(config) {
+    this.schema = config.schema;
+    this.storage = config.storage || /* @__PURE__ */ new Map();
+    this.cleanup();
+  }
+  async write(uri, payload) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return result;
+    }
+    const { program, node, parts } = result;
+    const validator = this.schema[program];
+    const validation = await validator({ uri, value: payload, read: this.read.bind(this) });
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: validation.error || "Validation failed"
+      };
+    }
+    const record = {
+      ts: Date.now(),
+      data: payload
+    };
+    let prev = node;
+    parts.filter(Boolean).forEach((ns) => {
+      if (!prev.children) prev.children = /* @__PURE__ */ new Map();
+      if (!prev.children.get(ns)) {
+        const newnode = {};
+        prev.children.set(ns, newnode);
+        prev = newnode;
+      } else {
+        prev = prev.children.get(ns);
+      }
+    });
+    prev.value = record;
+    return {
+      success: true,
+      record
+    };
+  }
+  read(uri) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts } = result;
+    let current = node;
+    for (const part of parts.filter(Boolean)) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.value) {
+      return Promise.resolve({
+        success: false,
+        error: "Not found"
+      });
+    }
+    return Promise.resolve({
+      success: true,
+      record: current.value
+    });
+  }
+  list(uri, options) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts, program, path } = result;
+    let current = node;
+    const filteredParts = parts.filter(Boolean);
+    for (const part of filteredParts) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.children?.size) {
+      return Promise.resolve({
+        success: true,
+        data: [],
+        pagination: {
+          page: options?.page ?? 1,
+          limit: options?.limit ?? 50,
+          total: 0
+        }
+      });
+    }
+    let items = Array.from(current.children.entries()).map(([key, child]) => ({
+      uri: path.endsWith("/") ? `${program}://${path}${key}` : `${program}://${path}/${key}`,
+      type: child.value ? "file" : "directory"
+    }));
+    if (options?.pattern) {
+      const regex = new RegExp(options.pattern);
+      items = items.filter((item) => regex.test(item.uri));
+    }
+    if (options?.sortBy === "name") {
+      items.sort((a, b) => a.uri.localeCompare(b.uri));
+    } else if (options?.sortBy === "timestamp") {
+      items.sort((a, b) => {
+        const aTs = current.children?.get(a.uri.split("/").pop())?.value?.ts ?? 0;
+        const bTs = current.children?.get(b.uri.split("/").pop())?.value?.ts ?? 0;
+        return aTs - bTs;
+      });
+    }
+    if (options?.sortOrder === "desc") {
+      items.reverse();
+    }
+    const page = options?.page ?? 1;
+    const limit = options?.limit ?? 50;
+    const offset = (page - 1) * limit;
+    const paginated = items.slice(offset, offset + limit);
+    return Promise.resolve({
+      success: true,
+      data: paginated,
+      pagination: { page, limit, total: items.length }
+    });
+  }
+  health() {
+    return Promise.resolve({
+      status: "healthy"
+    });
+  }
+  getSchema() {
+    return Promise.resolve(Object.keys(this.schema));
+  }
+  cleanup() {
+    Object.keys(this.schema).forEach((program) => {
+      if (!this.storage.get(program)) {
+        this.storage.set(program, { children: /* @__PURE__ */ new Map() });
+      }
+    });
+    return Promise.resolve();
+  }
+  delete(uri) {
+    const result = target(uri, this.schema, this.storage);
+    if (!result.success) {
+      return Promise.resolve(result);
+    }
+    const { node, parts } = result;
+    const filteredParts = parts.filter(Boolean);
+    if (filteredParts.length === 0) {
+      return Promise.resolve({
+        success: false,
+        error: "Cannot delete root path"
+      });
+    }
+    let current = node;
+    const lastPart = filteredParts.pop();
+    for (const part of filteredParts) {
+      current = current?.children?.get(part);
+      if (!current) {
+        return Promise.resolve({
+          success: false,
+          error: `Path not found: ${part}`
+        });
+      }
+    }
+    if (!current.children?.has(lastPart)) {
+      return Promise.resolve({
+        success: false,
+        error: `Item not found: ${lastPart}`
+      });
+    }
+    current.children.delete(lastPart);
+    return Promise.resolve({
+      success: true
+    });
+  }
+};
+export {
+  MemoryClient
+};

package/dist/core-CgxQpSVM.d.ts

@@ -0,0 +1,275 @@
+import { Hono } from 'hono';
+import { N as NodeProtocolInterface } from './types-oQCx3U-_.js';
+
+/**
+ * Wallet Server Dependency Injection Interfaces
+ *
+ * These interfaces abstract runtime-specific operations, enabling the wallet
+ * server to run in Deno, Node.js, or browsers through dependency injection.
+ */
+/**
+ * File storage abstraction - replaces Deno.readTextFile/writeTextFile
+ */
+interface FileStorage {
+    readTextFile(path: string): Promise<string>;
+    writeTextFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+/**
+ * Environment abstraction - replaces Deno.env.get()
+ */
+interface Environment {
+    get(key: string): string | undefined;
+}
+/**
+ * Logger abstraction - replaces console.log/warn/error
+ */
+interface Logger {
+    log(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+/**
+ * HTTP fetch abstraction - allows custom fetch implementations
+ */
+type HttpFetch = (url: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Default console logger implementation
+ */
+declare const defaultLogger: Logger;
+/**
+ * In-memory file storage implementation (for testing/browser)
+ */
+declare class MemoryFileStorage implements FileStorage {
+    private storage;
+    readTextFile(path: string): Promise<string>;
+    writeTextFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+/**
+ * Environment from config object (for testing/browser)
+ */
+declare class ConfigEnvironment implements Environment {
+    private config;
+    constructor(config?: Record<string, string>);
+    get(key: string): string | undefined;
+}
+
+/**
+ * Wallet Server Types
+ *
+ * Type definitions for the universal wallet server SDK.
+ */
+
+/**
+ * Server key pair configuration
+ */
+interface ServerKeyPair {
+    privateKeyPem: string;
+    publicKeyHex: string;
+}
+/**
+ * Server keys configuration (identity + encryption)
+ */
+interface ServerKeys {
+    identityKey: ServerKeyPair;
+    encryptionKey: ServerKeyPair;
+}
+/**
+ * App backend configuration for bootstrap
+ */
+interface AppBackendConfig {
+    url: string;
+    apiBasePath?: string;
+}
+/**
+ * Dependency injection configuration
+ */
+interface WalletServerDeps {
+    /** File storage for bootstrap state persistence */
+    storage?: FileStorage;
+    /** Logger for output */
+    logger?: Logger;
+    /** Custom fetch implementation */
+    fetch?: HttpFetch;
+    /** Pre-configured credential client (alternative to credentialNodeUrl) */
+    credentialClient?: NodeProtocolInterface;
+    /** Pre-configured proxy client (alternative to proxyNodeUrl) */
+    proxyClient?: NodeProtocolInterface;
+}
+/**
+ * Wallet server configuration
+ */
+interface WalletServerConfig {
+    /** Server identity and encryption keys */
+    serverKeys: ServerKeys;
+    /** JWT secret for token signing (must be 32+ characters) */
+    jwtSecret: string;
+    /** JWT expiration in seconds (default: 86400 = 24 hours) */
+    jwtExpirationSeconds?: number;
+    /** URL of the credential backend node */
+    credentialNodeUrl?: string;
+    /** URL of the proxy backend node */
+    proxyNodeUrl?: string;
+    /** CORS allowed origins (default: ["*"]) */
+    allowedOrigins?: string[];
+    /** App backend for bootstrap (optional) */
+    appBackend?: AppBackendConfig;
+    /** Password reset token TTL in seconds (default: 3600 = 1 hour) */
+    passwordResetTokenTtlSeconds?: number;
+    /** Google OAuth client ID (optional, enables Google auth) */
+    googleClientId?: string;
+    /** Path for bootstrap state file (optional) */
+    bootstrapStatePath?: string;
+    /** Dependency injection */
+    deps?: WalletServerDeps;
+}
+/**
+ * Resolved configuration with defaults applied
+ */
+interface ResolvedWalletServerConfig {
+    serverKeys: ServerKeys;
+    jwtSecret: string;
+    jwtExpirationSeconds: number;
+    allowedOrigins: string[];
+    passwordResetTokenTtlSeconds: number;
+    googleClientId: string | null;
+    bootstrapStatePath: string | null;
+    appBackend: AppBackendConfig | null;
+}
+/**
+ * User keys structure
+ */
+interface UserKeys {
+    accountKey: ServerKeyPair;
+    encryptionKey: ServerKeyPair;
+}
+/**
+ * Proxy write request
+ */
+interface ProxyWriteRequest {
+    uri: string;
+    data: unknown;
+    encrypt?: boolean;
+}
+/**
+ * Proxy write response
+ */
+interface ProxyWriteResponse {
+    success: boolean;
+    resolvedUri?: string;
+    error?: string;
+    record?: {
+        data: unknown;
+        ts: number;
+    };
+}
+/**
+ * Proxy read response
+ */
+interface ProxyReadResponse {
+    success: boolean;
+    error?: string;
+    record?: {
+        data: unknown;
+        ts: number;
+    };
+    decrypted?: unknown;
+}
+/**
+ * Auth session response
+ */
+interface AuthSessionResponse {
+    success: boolean;
+    username: string;
+    token: string;
+    expiresIn: number;
+    error?: string;
+    email?: string;
+    name?: string;
+    picture?: string;
+}
+/**
+ * Public keys response
+ */
+interface PublicKeysResponse {
+    success: boolean;
+    accountPublicKeyHex?: string;
+    encryptionPublicKeyHex?: string;
+    error?: string;
+}
+/**
+ * Health response
+ */
+interface HealthResponse {
+    success: boolean;
+    status: string;
+    server: string;
+    timestamp: string;
+}
+/**
+ * Server keys response
+ */
+interface ServerKeysResponse {
+    success: boolean;
+    identityPublicKeyHex: string;
+    encryptionPublicKeyHex: string;
+}
+
+/**
+ * Wallet Server Core
+ *
+ * Universal wallet server that works in Deno, Node.js, and browsers.
+ * Uses dependency injection for all runtime-specific operations.
+ */
+
+interface BootstrapState {
+    appKey: string;
+    createdAt: string;
+    appServerUrl: string;
+    apiBasePath: string;
+}
+/**
+ * Wallet Server Core
+ *
+ * Creates a portable Hono application that can be served by any runtime.
+ */
+declare class WalletServerCore {
+    private config;
+    private serverKeys;
+    private credentialClient;
+    private proxyClient;
+    private app;
+    private logger;
+    private storage;
+    private fetchImpl;
+    constructor(userConfig: WalletServerConfig);
+    private validateConfig;
+    private applyDefaults;
+    /**
+     * Get the Hono app instance
+     */
+    getApp(): Hono;
+    /**
+     * Get the fetch handler for use with various runtimes
+     */
+    getFetchHandler(): (request: Request) => Response | Promise<Response>;
+    /**
+     * Get server public keys
+     */
+    getServerKeys(): {
+        identityPublicKeyHex: string;
+        encryptionPublicKeyHex: string;
+    };
+    /**
+     * Bootstrap wallet app registration (optional)
+     */
+    bootstrap(): Promise<BootstrapState | null>;
+    private normalizeApiBasePath;
+    private readBootstrapState;
+    private writeBootstrapState;
+    private sessionExists;
+    private createApp;
+}
+
+export { type AppBackendConfig as A, ConfigEnvironment as C, type Environment as E, type FileStorage as F, type HttpFetch as H, type Logger as L, MemoryFileStorage as M, type ProxyWriteRequest as P, type ResolvedWalletServerConfig as R, type ServerKeys as S, type UserKeys as U, WalletServerCore as W, type ProxyWriteResponse as a, type ProxyReadResponse as b, type WalletServerConfig as c, type WalletServerDeps as d, type ServerKeyPair as e, type AuthSessionResponse as f, type PublicKeysResponse as g, type HealthResponse as h, type ServerKeysResponse as i, defaultLogger as j };

package/dist/encrypt/mod.d.ts

@@ -1 +1 @@
-export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, I as IdentityKey, K as KeyPair, d as PrivateEncryptionKey, P as PublicEncryptionKey, c as SecretEncryptionKey, S as SignedEncryptedMessage, b as SignedSymmetricMessage, k as createAuthenticatedMessage, l as createAuthenticatedMessageWithHex, w as createSignedEncryptedMessage, B as createSignedSymmetricMessage, i as decrypt, z as decryptSymmetric, j as decryptWithHex, n as deriveKeyFromSeed, h as encrypt, y as encryptSymmetric, r as exportPrivateKeyPem, e as generateEncryptionKeyPair, o as generateNonce, q as generateRandomData, g as generateSigningKeyPair, p as pemToCryptoKey, s as sign, t as signPayload, f as signWithHex, v as verify, x as verifyAndDecryptMessage, u as verifyPayload } from '../mod-D02790g_.js';
+export { A as AuthenticatedMessage, E as EncryptedPayload, a as EncryptionKeyPair, I as IdentityKey, K as KeyPair, d as PrivateEncryptionKey, P as PublicEncryptionKey, c as SecretEncryptionKey, S as SignedEncryptedMessage, b as SignedSymmetricMessage, k as createAuthenticatedMessage, l as createAuthenticatedMessageWithHex, w as createSignedEncryptedMessage, B as createSignedSymmetricMessage, i as decrypt, z as decryptSymmetric, j as decryptWithHex, n as deriveKeyFromSeed, h as encrypt, y as encryptSymmetric, r as exportPrivateKeyPem, e as generateEncryptionKeyPair, o as generateNonce, q as generateRandomData, g as generateSigningKeyPair, p as pemToCryptoKey, s as sign, t as signPayload, f as signWithHex, v as verify, x as verifyAndDecryptMessage, u as verifyPayload } from '../mod-CII9wqu2.js';

package/dist/encrypt/mod.js

@@ -25,7 +25,7 @@ import {
   verify,
   verifyAndDecryptMessage,
   verifyPayload
-} from "../chunk-K3ZSSVHR.js";
+} from "../chunk-JN75UL5C.js";
 import "../chunk-MLKGABMK.js";
 export {
   IdentityKey,

package/dist/{mod-D02790g_.d.ts → mod-CII9wqu2.d.ts}

@@ -238,4 +238,4 @@ declare namespace mod {
   export { type mod_AuthenticatedMessage as AuthenticatedMessage, type mod_EncryptedPayload as EncryptedPayload, type mod_EncryptionKeyPair as EncryptionKeyPair, mod_IdentityKey as IdentityKey, type mod_KeyPair as KeyPair, mod_PrivateEncryptionKey as PrivateEncryptionKey, mod_PublicEncryptionKey as PublicEncryptionKey, mod_SecretEncryptionKey as SecretEncryptionKey, type mod_SignedEncryptedMessage as SignedEncryptedMessage, type mod_SignedSymmetricMessage as SignedSymmetricMessage, mod_createAuthenticatedMessage as createAuthenticatedMessage, mod_createAuthenticatedMessageWithHex as createAuthenticatedMessageWithHex, mod_createSignedEncryptedMessage as createSignedEncryptedMessage, mod_createSignedSymmetricMessage as createSignedSymmetricMessage, mod_decrypt as decrypt, mod_decryptSymmetric as decryptSymmetric, mod_decryptWithHex as decryptWithHex, mod_deriveKeyFromSeed as deriveKeyFromSeed, mod_encrypt as encrypt, mod_encryptSymmetric as encryptSymmetric, mod_exportPrivateKeyPem as exportPrivateKeyPem, mod_generateEncryptionKeyPair as generateEncryptionKeyPair, mod_generateNonce as generateNonce, mod_generateRandomData as generateRandomData, mod_generateSigningKeyPair as generateSigningKeyPair, mod_pemToCryptoKey as pemToCryptoKey, mod_sign as sign, mod_signPayload as signPayload, mod_signWithHex as signWithHex, mod_verify as verify, mod_verifyAndDecryptMessage as verifyAndDecryptMessage, mod_verifyPayload as verifyPayload };
 }
 
-export { type AuthenticatedMessage as A, createSignedSymmetricMessage as B, type EncryptionKeyPair as E, IdentityKey as I, type KeyPair as K, PublicEncryptionKey as P, type SignedEncryptedMessage as S, type EncryptedPayload as a, type SignedSymmetricMessage as b, SecretEncryptionKey as c, PrivateEncryptionKey as d, generateEncryptionKeyPair as e, signWithHex as f, generateSigningKeyPair as g, encrypt as h, decrypt as i, decryptWithHex as j, createAuthenticatedMessage as k, createAuthenticatedMessageWithHex as l, mod as m, deriveKeyFromSeed as n, generateNonce as o, pemToCryptoKey as p, generateRandomData as q, exportPrivateKeyPem as r, sign as s, signPayload as t, verifyPayload as u, verify as v, createSignedEncryptedMessage as w, verifyAndDecryptMessage as x, encryptSymmetric as y, decryptSymmetric as z };
+export { type AuthenticatedMessage as A, createSignedSymmetricMessage as B, type EncryptedPayload as E, IdentityKey as I, type KeyPair as K, PublicEncryptionKey as P, type SignedEncryptedMessage as S, type EncryptionKeyPair as a, type SignedSymmetricMessage as b, SecretEncryptionKey as c, PrivateEncryptionKey as d, generateEncryptionKeyPair as e, signWithHex as f, generateSigningKeyPair as g, encrypt as h, decrypt as i, decryptWithHex as j, createAuthenticatedMessage as k, createAuthenticatedMessageWithHex as l, mod as m, deriveKeyFromSeed as n, generateNonce as o, pemToCryptoKey as p, generateRandomData as q, exportPrivateKeyPem as r, sign as s, signPayload as t, verifyPayload as u, verify as v, createSignedEncryptedMessage as w, verifyAndDecryptMessage as x, encryptSymmetric as y, decryptSymmetric as z };

package/dist/src/mod.web.d.ts

@@ -4,4 +4,4 @@ export { WebSocketClient } from '../clients/websocket/mod.js';
 export { LocalStorageClient } from '../clients/local-storage/mod.js';
 export { WalletClient } from '../wallet/mod.js';
 export { AppsClient } from '../apps/mod.js';
-export { m as encrypt } from '../mod-D02790g_.js';
+export { m as encrypt } from '../mod-CII9wqu2.js';

package/dist/src/mod.web.js

@@ -1,6 +1,12 @@
+import {
+  WebSocketClient
+} from "../chunk-T43IWAQK.js";
+import {
+  AppsClient
+} from "../chunk-VAZUCGED.js";
 import {
   mod_exports
-} from "../chunk-K3ZSSVHR.js";
+} from "../chunk-JN75UL5C.js";
 import {
   WalletClient
 } from "../chunk-S7NJA6B6.js";
@@ -10,12 +16,6 @@ import {
 import {
   LocalStorageClient
 } from "../chunk-7U5JDFQW.js";
-import {
-  WebSocketClient
-} from "../chunk-T43IWAQK.js";
-import {
-  AppsClient
-} from "../chunk-VAZUCGED.js";
 import "../chunk-MLKGABMK.js";
 export {
   AppsClient,

package/dist/wallet-server/adapters/browser.d.ts

@@ -0,0 +1,76 @@
+import { F as FileStorage, S as ServerKeys, W as WalletServerCore } from '../../core-CgxQpSVM.js';
+export { C as BrowserEnvironment, M as BrowserMemoryStorage } from '../../core-CgxQpSVM.js';
+import 'hono';
+import '../../types-oQCx3U-_.js';
+
+/**
+ * Browser Adapter for Wallet Server
+ *
+ * Provides browser-compatible implementations for running a wallet server
+ * in simulation/demo mode using in-memory or localStorage storage.
+ */
+
+/**
+ * Browser localStorage-backed file storage
+ */
+declare class BrowserLocalStorageFileStorage implements FileStorage {
+    private keyPrefix;
+    constructor(keyPrefix?: string);
+    readTextFile(path: string): Promise<string>;
+    writeTextFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+
+/**
+ * Options for creating a browser wallet server
+ */
+interface BrowserWalletServerOptions {
+    /** Server keys (required) */
+    serverKeys: ServerKeys;
+    /** JWT secret (required, must be 32+ chars) */
+    jwtSecret: string;
+    /** Use localStorage for persistence (default: false = in-memory) */
+    useLocalStorage?: boolean;
+    /** Key prefix for localStorage (default: "b3nd-wallet-") */
+    localStoragePrefix?: string;
+    /** JWT expiration in seconds (default: 86400) */
+    jwtExpirationSeconds?: number;
+    /** Allowed origins (default: ["*"]) */
+    allowedOrigins?: string[];
+    /** Google OAuth client ID (optional) */
+    googleClientId?: string;
+}
+/**
+ * Create a browser-compatible wallet server for simulation/testing
+ *
+ * This creates a fully functional wallet server that runs in the browser
+ * using LocalStorageClient as the backend. Useful for:
+ * - Demo applications
+ * - Testing without a real backend
+ * - Offline-first applications
+ *
+ * @example
+ * ```typescript
+ * import { createBrowserWalletServer, generateBrowserServerKeys } from "@b3nd/sdk/wallet-server/adapters/browser";
+ *
+ * const serverKeys = await generateBrowserServerKeys();
+ * const server = createBrowserWalletServer({
+ *   serverKeys,
+ *   jwtSecret: "your-32-character-minimum-secret!!",
+ *   useLocalStorage: true,
+ * });
+ *
+ * // Use with fetch API
+ * const response = await server.getFetchHandler()(new Request("/api/v1/health"));
+ * ```
+ */
+declare function createBrowserWalletServer(options: BrowserWalletServerOptions): WalletServerCore;
+/**
+ * Generate server keys in the browser
+ *
+ * Creates Ed25519 (identity) and X25519 (encryption) key pairs
+ * using the Web Crypto API.
+ */
+declare function generateBrowserServerKeys(): Promise<ServerKeys>;
+
+export { BrowserLocalStorageFileStorage, type BrowserWalletServerOptions, createBrowserWalletServer, generateBrowserServerKeys };