@bandeira-tech/b3nd-web 0.2.0

package/dist/chunk-XH4OLKBV.js

@@ -0,0 +1,295 @@
+// clients/local-storage/mod.ts
+var LocalStorageClient = class {
+  config;
+  schema;
+  storage;
+  constructor(config) {
+    this.config = {
+      keyPrefix: config.keyPrefix || "b3nd:",
+      serializer: {
+        serialize: (data) => JSON.stringify(data),
+        deserialize: (data) => JSON.parse(data),
+        ...config.serializer
+      }
+    };
+    this.schema = config.schema || {};
+    this.storage = config.storage || (typeof localStorage !== "undefined" ? localStorage : null);
+    if (!this.storage) {
+      throw new Error("localStorage is not available in this environment");
+    }
+  }
+  /**
+   * Get the localStorage key for a URI
+   */
+  getKey(uri) {
+    return `${this.config.keyPrefix}${uri}`;
+  }
+  /**
+   * Validate write operation against schema
+   */
+  async validateWrite(uri, value) {
+    const programKey = this.findMatchingProgram(uri);
+    if (programKey && this.schema[programKey]) {
+      const validator = this.schema[programKey];
+      return await validator({ uri, value, read: this.read.bind(this) });
+    }
+    return { valid: true };
+  }
+  /**
+   * Find matching program key for URI
+   */
+  findMatchingProgram(uri) {
+    for (const programKey of Object.keys(this.schema)) {
+      if (uri.startsWith(programKey)) {
+        return programKey;
+      }
+    }
+    return null;
+  }
+  /**
+   * Serialize data using configured serializer
+   */
+  serialize(data) {
+    return this.config.serializer.serialize(data);
+  }
+  /**
+   * Deserialize data using configured serializer
+   */
+  deserialize(data) {
+    return this.config.serializer.deserialize(data);
+  }
+  async write(uri, value) {
+    try {
+      const validation = await this.validateWrite(uri, value);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: validation.error || "Validation failed"
+        };
+      }
+      const key = this.getKey(uri);
+      const record = {
+        ts: Date.now(),
+        data: value
+      };
+      const serialized = this.serialize(record);
+      this.storage.setItem(key, serialized);
+      return {
+        success: true,
+        record
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async read(uri) {
+    try {
+      const key = this.getKey(uri);
+      const serialized = this.storage.getItem(key);
+      if (serialized === null) {
+        return {
+          success: false,
+          error: "Not found"
+        };
+      }
+      const record = this.deserialize(serialized);
+      return {
+        success: true,
+        record
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async list(uri, options) {
+    try {
+      const { page = 1, limit = 50, pattern, sortBy = "name", sortOrder = "asc" } = options || {};
+      const items = [];
+      const prefix = this.getKey(uri);
+      for (let i = 0; i < this.storage.length; i++) {
+        const key = this.storage.key(i);
+        if (key && key.startsWith(prefix)) {
+          const uri2 = key.substring(this.config.keyPrefix.length);
+          if (pattern && !uri2.includes(pattern)) {
+            continue;
+          }
+          const isDirectory = this.hasChildren(uri2);
+          items.push({
+            uri: uri2,
+            type: isDirectory ? "directory" : "file"
+          });
+        }
+      }
+      items.sort((a, b) => {
+        let comparison = 0;
+        if (sortBy === "name") {
+          comparison = a.uri.localeCompare(b.uri);
+        } else if (sortBy === "timestamp") {
+          const aData = this.getStoredData(a.uri);
+          const bData = this.getStoredData(b.uri);
+          const aTs = (aData == null ? void 0 : aData.ts) || 0;
+          const bTs = (bData == null ? void 0 : bData.ts) || 0;
+          comparison = aTs - bTs;
+        }
+        return sortOrder === "asc" ? comparison : -comparison;
+      });
+      const startIndex = (page - 1) * limit;
+      const endIndex = startIndex + limit;
+      const paginatedItems = items.slice(startIndex, endIndex);
+      return {
+        success: true,
+        data: paginatedItems,
+        pagination: {
+          page,
+          limit,
+          total: items.length
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Check if a URI has children (is a directory)
+   */
+  hasChildren(uri) {
+    const prefix = this.getKey(uri) + "/";
+    for (let i = 0; i < this.storage.length; i++) {
+      const key = this.storage.key(i);
+      if (key && key.startsWith(prefix)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Get stored data for a URI (for timestamp sorting)
+   */
+  getStoredData(uri) {
+    try {
+      const key = this.getKey(uri);
+      const serialized = this.storage.getItem(key);
+      if (serialized) {
+        return this.deserialize(serialized);
+      }
+    } catch {
+    }
+    return null;
+  }
+  async delete(uri) {
+    try {
+      const key = this.getKey(uri);
+      const exists = this.storage.getItem(key) !== null;
+      if (!exists) {
+        return {
+          success: false,
+          error: "Not found"
+        };
+      }
+      this.storage.removeItem(key);
+      return {
+        success: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async health() {
+    try {
+      const testKey = `${this.config.keyPrefix}health-check`;
+      this.storage.setItem(testKey, "test");
+      this.storage.removeItem(testKey);
+      const stats = this.getStorageStats();
+      return {
+        status: "healthy",
+        message: "LocalStorage client is operational",
+        details: stats
+      };
+    } catch (error) {
+      return {
+        status: "unhealthy",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get localStorage usage statistics
+   */
+  getStorageStats() {
+    try {
+      let totalKeys = 0;
+      let b3ndKeys = 0;
+      let totalSize = 0;
+      for (let i = 0; i < this.storage.length; i++) {
+        const key = this.storage.key(i);
+        if (key) {
+          totalKeys++;
+          const value = this.storage.getItem(key) || "";
+          totalSize += key.length + value.length;
+          if (key.startsWith(this.config.keyPrefix)) {
+            b3ndKeys++;
+          }
+        }
+      }
+      return {
+        totalKeys,
+        b3ndKeys,
+        totalSize,
+        keyPrefix: this.config.keyPrefix,
+        estimatedRemainingSpace: this.estimateRemainingSpace()
+      };
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Estimate remaining localStorage space (rough approximation)
+   */
+  estimateRemainingSpace() {
+    try {
+      const typicalLimit = 5 * 1024 * 1024;
+      let currentSize = 0;
+      for (let i = 0; i < this.storage.length; i++) {
+        const key = this.storage.key(i);
+        if (key) {
+          const value = this.storage.getItem(key) || "";
+          currentSize += key.length + value.length;
+        }
+      }
+      return Math.max(0, typicalLimit - currentSize);
+    } catch {
+      return 0;
+    }
+  }
+  async getSchema() {
+    return Object.keys(this.schema);
+  }
+  async cleanup() {
+    const keysToRemove = [];
+    for (let i = 0; i < this.storage.length; i++) {
+      const key = this.storage.key(i);
+      if (key && key.startsWith(this.config.keyPrefix)) {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      this.storage.removeItem(key);
+    }
+  }
+};
+
+export {
+  LocalStorageClient
+};

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

@@ -0,0 +1,33 @@
+import { N as NodeProtocolInterface, a as HttpClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+
+/**
+ * HttpClient - HTTP implementation of NodeProtocolInterface
+ *
+ * Connects to B3nd HTTP API servers and forwards operations.
+ * No schema validation - validation happens server-side.
+ */
+
+declare class HttpClient implements NodeProtocolInterface {
+    private baseUrl;
+    private headers;
+    private timeout;
+    constructor(config: HttpClientConfig);
+    /**
+     * Make an HTTP request with timeout
+     */
+    private request;
+    /**
+     * Parse URI into components
+     * Example: "users://alice/profile" -> { protocol: "users", domain: "alice", path: "/profile" }
+     */
+    private parseUri;
+    write<T = unknown>(uri: string, value: T): Promise<WriteResult<T>>;
+    read<T = unknown>(uri: string): Promise<ReadResult<T>>;
+    list(uri: string, options?: ListOptions): Promise<ListResult>;
+    delete(uri: string): Promise<DeleteResult>;
+    health(): Promise<HealthStatus>;
+    getSchema(): Promise<string[]>;
+    cleanup(): Promise<void>;
+}
+
+export { HttpClient };

package/dist/clients/http/mod.js

@@ -0,0 +1,7 @@
+import {
+  HttpClient
+} from "../../chunk-PMBS2GFA.js";
+import "../../chunk-MLKGABMK.js";
+export {
+  HttpClient
+};

package/dist/clients/local-storage/mod.d.ts

@@ -0,0 +1,60 @@
+import { N as NodeProtocolInterface, d as LocalStorageClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+
+/**
+ * LocalStorageClient - Browser localStorage implementation of NodeProtocolInterface
+ *
+ * Provides persistent storage in browser environments using localStorage.
+ * Supports schema validation and custom serialization.
+ */
+
+declare class LocalStorageClient implements NodeProtocolInterface {
+    private config;
+    private schema;
+    private storage;
+    constructor(config: LocalStorageClientConfig);
+    /**
+     * Get the localStorage key for a URI
+     */
+    private getKey;
+    /**
+     * Validate write operation against schema
+     */
+    private validateWrite;
+    /**
+     * Find matching program key for URI
+     */
+    private findMatchingProgram;
+    /**
+     * Serialize data using configured serializer
+     */
+    private serialize;
+    /**
+     * Deserialize data using configured serializer
+     */
+    private deserialize;
+    write<T = unknown>(uri: string, value: T): Promise<WriteResult<T>>;
+    read<T = unknown>(uri: string): Promise<ReadResult<T>>;
+    list(uri: string, options?: ListOptions): Promise<ListResult>;
+    /**
+     * Check if a URI has children (is a directory)
+     */
+    private hasChildren;
+    /**
+     * Get stored data for a URI (for timestamp sorting)
+     */
+    private getStoredData;
+    delete(uri: string): Promise<DeleteResult>;
+    health(): Promise<HealthStatus>;
+    /**
+     * Get localStorage usage statistics
+     */
+    private getStorageStats;
+    /**
+     * Estimate remaining localStorage space (rough approximation)
+     */
+    private estimateRemainingSpace;
+    getSchema(): Promise<string[]>;
+    cleanup(): Promise<void>;
+}
+
+export { LocalStorageClient };

package/dist/clients/local-storage/mod.js

@@ -0,0 +1,7 @@
+import {
+  LocalStorageClient
+} from "../../chunk-XH4OLKBV.js";
+import "../../chunk-MLKGABMK.js";
+export {
+  LocalStorageClient
+};

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

@@ -0,0 +1,62 @@
+import { N as NodeProtocolInterface, W as WebSocketClientConfig, g as WriteResult, R as ReadResult, b as ListOptions, c as ListResult, D as DeleteResult, H as HealthStatus } from '../../types-Bw0Boe0n.js';
+
+/**
+ * WebSocketClient - WebSocket implementation of NodeProtocolInterface
+ *
+ * Connects to B3nd WebSocket servers and forwards operations.
+ * Handles reconnection and connection pooling.
+ */
+
+declare class WebSocketClient implements NodeProtocolInterface {
+    private config;
+    private ws;
+    private connected;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private pendingRequests;
+    private messageHandler;
+    private closeHandler;
+    private errorHandler;
+    constructor(config: WebSocketClientConfig);
+    /**
+     * Ensure WebSocket connection is established
+     */
+    private ensureConnected;
+    /**
+     * Establish WebSocket connection
+     */
+    private connect;
+    /**
+     * Handle WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Handle WebSocket close
+     */
+    private handleClose;
+    /**
+     * Handle WebSocket errors
+     */
+    private handleError;
+    /**
+     * Schedule reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Cleanup pending requests with error
+     */
+    private cleanupPendingRequests;
+    /**
+     * Send request and wait for response
+     */
+    private sendRequest;
+    write<T = unknown>(uri: string, value: T): Promise<WriteResult<T>>;
+    read<T = unknown>(uri: string): Promise<ReadResult<T>>;
+    list(uri: string, options?: ListOptions): Promise<ListResult>;
+    delete(uri: string): Promise<DeleteResult>;
+    health(): Promise<HealthStatus>;
+    getSchema(): Promise<string[]>;
+    cleanup(): Promise<void>;
+}
+
+export { WebSocketClient };

package/dist/clients/websocket/mod.js

@@ -0,0 +1,7 @@
+import {
+  WebSocketClient
+} from "../../chunk-C2ZIFM22.js";
+import "../../chunk-MLKGABMK.js";
+export {
+  WebSocketClient
+};

package/dist/encrypt/mod.d.ts

@@ -0,0 +1 @@
+export { A as AuthenticatedMessage, a as EncryptedPayload, E as EncryptionKeyPair, K as KeyPair, S as SignedEncryptedMessage, h as createAuthenticatedMessage, i as createSignedEncryptedMessage, d as decrypt, f as decryptWithHex, e as encrypt, b as generateEncryptionKeyPair, k as generateNonce, l as generateRandomData, g as generateSigningKeyPair, s as sign, c as signWithHex, v as verify, j as verifyAndDecrypt } from '../mod-DHjjiF1o.js';

package/dist/encrypt/mod.js

@@ -0,0 +1,31 @@
+import {
+  createAuthenticatedMessage,
+  createSignedEncryptedMessage,
+  decrypt,
+  decryptWithHex,
+  encrypt,
+  generateEncryptionKeyPair,
+  generateNonce,
+  generateRandomData,
+  generateSigningKeyPair,
+  sign,
+  signWithHex,
+  verify,
+  verifyAndDecrypt
+} from "../chunk-G6JDROB4.js";
+import "../chunk-MLKGABMK.js";
+export {
+  createAuthenticatedMessage,
+  createSignedEncryptedMessage,
+  decrypt,
+  decryptWithHex,
+  encrypt,
+  generateEncryptionKeyPair,
+  generateNonce,
+  generateRandomData,
+  generateSigningKeyPair,
+  sign,
+  signWithHex,
+  verify,
+  verifyAndDecrypt
+};

package/dist/mod-DHjjiF1o.d.ts

@@ -0,0 +1,111 @@
+interface KeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+    privateKeyHex: string;
+}
+interface EncryptionKeyPair {
+    publicKey: CryptoKey;
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}
+interface EncryptedPayload {
+    data: string;
+    nonce: string;
+    ephemeralPublicKey?: string;
+}
+interface AuthenticatedMessage<T = unknown> {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: T;
+}
+interface SignedEncryptedMessage {
+    auth: Array<{
+        pubkey: string;
+        signature: string;
+    }>;
+    payload: EncryptedPayload;
+}
+/**
+ * Generate an Ed25519 keypair for signing
+ */
+declare function generateSigningKeyPair(): Promise<KeyPair>;
+/**
+ * Generate an X25519 keypair for encryption (ECDH)
+ */
+declare function generateEncryptionKeyPair(): Promise<EncryptionKeyPair>;
+/**
+ * Sign a payload with an Ed25519 private key
+ */
+declare function sign<T>(privateKey: CryptoKey, payload: T): Promise<string>;
+/**
+ * Sign a payload with an Ed25519 private key from hex
+ */
+declare function signWithHex<T>(privateKeyHex: string, payload: T): Promise<string>;
+/**
+ * Verify a signature using Ed25519 public key
+ */
+declare function verify<T>(publicKeyHex: string, signatureHex: string, payload: T): Promise<boolean>;
+/**
+ * Encrypt data using X25519 ECDH + AES-GCM
+ * Uses ephemeral keypair for forward secrecy
+ */
+declare function encrypt(data: unknown, recipientPublicKeyHex: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt data using X25519 ECDH + AES-GCM
+ */
+declare function decrypt(encryptedPayload: EncryptedPayload, recipientPrivateKey: CryptoKey): Promise<unknown>;
+/**
+ * Decrypt data using private key from hex
+ */
+declare function decryptWithHex(encryptedPayload: EncryptedPayload, recipientPrivateKeyHex: string): Promise<unknown>;
+/**
+ * Create an authenticated message (signed but not encrypted)
+ */
+declare function createAuthenticatedMessage<T>(payload: T, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>): Promise<AuthenticatedMessage<T>>;
+/**
+ * Create a signed and encrypted message
+ */
+declare function createSignedEncryptedMessage(data: unknown, signers: Array<{
+    privateKey: CryptoKey;
+    publicKeyHex: string;
+}>, recipientPublicKeyHex: string): Promise<SignedEncryptedMessage>;
+/**
+ * Verify and decrypt a signed encrypted message
+ */
+declare function verifyAndDecrypt(message: SignedEncryptedMessage, recipientPrivateKey: CryptoKey): Promise<{
+    data: unknown;
+    verified: boolean;
+    signers: string[];
+}>;
+declare function generateNonce(length?: number): Uint8Array;
+declare function generateRandomData(size: number): Uint8Array;
+
+type mod_AuthenticatedMessage<T = unknown> = AuthenticatedMessage<T>;
+type mod_EncryptedPayload = EncryptedPayload;
+type mod_EncryptionKeyPair = EncryptionKeyPair;
+type mod_KeyPair = KeyPair;
+type mod_SignedEncryptedMessage = SignedEncryptedMessage;
+declare const mod_createAuthenticatedMessage: typeof createAuthenticatedMessage;
+declare const mod_createSignedEncryptedMessage: typeof createSignedEncryptedMessage;
+declare const mod_decrypt: typeof decrypt;
+declare const mod_decryptWithHex: typeof decryptWithHex;
+declare const mod_encrypt: typeof encrypt;
+declare const mod_generateEncryptionKeyPair: typeof generateEncryptionKeyPair;
+declare const mod_generateNonce: typeof generateNonce;
+declare const mod_generateRandomData: typeof generateRandomData;
+declare const mod_generateSigningKeyPair: typeof generateSigningKeyPair;
+declare const mod_sign: typeof sign;
+declare const mod_signWithHex: typeof signWithHex;
+declare const mod_verify: typeof verify;
+declare const mod_verifyAndDecrypt: typeof verifyAndDecrypt;
+declare namespace mod {
+  export { type mod_AuthenticatedMessage as AuthenticatedMessage, type mod_EncryptedPayload as EncryptedPayload, type mod_EncryptionKeyPair as EncryptionKeyPair, type mod_KeyPair as KeyPair, type mod_SignedEncryptedMessage as SignedEncryptedMessage, mod_createAuthenticatedMessage as createAuthenticatedMessage, mod_createSignedEncryptedMessage as createSignedEncryptedMessage, mod_decrypt as decrypt, mod_decryptWithHex as decryptWithHex, mod_encrypt as encrypt, mod_generateEncryptionKeyPair as generateEncryptionKeyPair, mod_generateNonce as generateNonce, mod_generateRandomData as generateRandomData, mod_generateSigningKeyPair as generateSigningKeyPair, mod_sign as sign, mod_signWithHex as signWithHex, mod_verify as verify, mod_verifyAndDecrypt as verifyAndDecrypt };
+}
+
+export { type AuthenticatedMessage as A, type EncryptionKeyPair as E, type KeyPair as K, type SignedEncryptedMessage as S, type EncryptedPayload as a, generateEncryptionKeyPair as b, signWithHex as c, decrypt as d, encrypt as e, decryptWithHex as f, generateSigningKeyPair as g, createAuthenticatedMessage as h, createSignedEncryptedMessage as i, verifyAndDecrypt as j, generateNonce as k, generateRandomData as l, mod as m, sign as s, verify as v };

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

@@ -0,0 +1,7 @@
+export { C as ClientError, D as DeleteResult, H as HealthStatus, a as HttpClientConfig, L as ListItem, b as ListOptions, c as ListResult, d as LocalStorageClientConfig, N as NodeProtocolInterface, P as PersistenceRecord, R as ReadResult, S as Schema, V as ValidationFn, W as WebSocketClientConfig, e as WebSocketRequest, f as WebSocketResponse, g as WriteResult } from '../types-Bw0Boe0n.js';
+export { HttpClient } from '../clients/http/mod.js';
+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-DHjjiF1o.js';

package/dist/src/mod.web.js

@@ -0,0 +1,27 @@
+import {
+  AppsClient
+} from "../chunk-QHDBFVLU.js";
+import {
+  mod_exports
+} from "../chunk-G6JDROB4.js";
+import {
+  WalletClient
+} from "../chunk-2D2RT2DW.js";
+import {
+  HttpClient
+} from "../chunk-PMBS2GFA.js";
+import {
+  LocalStorageClient
+} from "../chunk-XH4OLKBV.js";
+import {
+  WebSocketClient
+} from "../chunk-C2ZIFM22.js";
+import "../chunk-MLKGABMK.js";
+export {
+  AppsClient,
+  HttpClient,
+  LocalStorageClient,
+  WalletClient,
+  WebSocketClient,
+  mod_exports as encrypt
+};