@massalabs/gossip-sdk 0.0.2-dev.20260130145448 → 0.0.2-dev.20260210150149

package/dist/contacts.d.ts

@@ -19,7 +19,7 @@
  */
 import { type Contact, type GossipDatabase } from './db';
 import type { UpdateContactNameResult, DeleteContactResult } from './utils/contacts';
-import type { UserPublicKeys } from '#wasm';
+import type { UserPublicKeys } from './wasm/bindings';
 import type { SessionModule } from './wasm/session';
 export type { UpdateContactNameResult, DeleteContactResult };
 /**

package/dist/gossipSdk.d.ts

@@ -46,7 +46,7 @@ import { type MessageResult, type SendMessageResult } from './services/message';
 import { AuthService } from './services/auth';
 import type { DeleteContactResult, UpdateContactNameResult } from './utils/contacts';
 import { type ValidationResult } from './utils/validation';
-import type { UserPublicKeys } from '#wasm';
+import type { UserPublicKeys } from './wasm/bindings';
 import { type SdkEventType, type SdkEventHandlers } from './core/SdkEventEmitter';
 export type { SdkEventType, SdkEventHandlers };
 export interface GossipSdkInitOptions {

package/dist/index.d.ts

@@ -4,9 +4,9 @@
  * Main entry point for the Gossip SDK.
  * Works in both browser and Node.js environments.
  *
- * WASM is loaded via the #wasm subpath import which resolves conditionally:
- * - Browser: web target (uses import.meta.url)
- * - Node: nodejs target (uses fs, no import.meta.url)
+ * WASM is loaded via the web target build with runtime detection:
+ * - Browser: init() uses import.meta.url + fetch
+ * - Node.js / Jiti: init(bytes) reads the .wasm file from disk
  *
  * @example
  * ```typescript
@@ -56,4 +56,4 @@ export { MESSAGE_TYPE_KEEP_ALIVE, serializeKeepAliveMessage, serializeRegularMes
 export type { DeserializedMessage } from './utils/messageSerialization';
 export { generateMnemonic, validateMnemonic, mnemonicToSeed, accountFromMnemonic, PRIVATE_KEY_VERSION, } from './crypto/bip39';
 export { encrypt, decrypt, deriveKey } from './crypto/encryption';
-export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from '#wasm';
+export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from './wasm/bindings';

package/dist/index.js

@@ -4,9 +4,9 @@
  * Main entry point for the Gossip SDK.
  * Works in both browser and Node.js environments.
  *
- * WASM is loaded via the #wasm subpath import which resolves conditionally:
- * - Browser: web target (uses import.meta.url)
- * - Node: nodejs target (uses fs, no import.meta.url)
+ * WASM is loaded via the web target build with runtime detection:
+ * - Browser: init() uses import.meta.url + fetch
+ * - Node.js / Jiti: init(bytes) reads the .wasm file from disk
  *
  * @example
  * ```typescript
@@ -58,4 +58,4 @@ export { MESSAGE_TYPE_KEEP_ALIVE, serializeKeepAliveMessage, serializeRegularMes
 export { generateMnemonic, validateMnemonic, mnemonicToSeed, accountFromMnemonic, PRIVATE_KEY_VERSION, } from './crypto/bip39';
 export { encrypt, decrypt, deriveKey } from './crypto/encryption';
 // WASM types re-exported for convenience
-export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from '#wasm';
+export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from './wasm/bindings';

package/dist/services/announcement.d.ts

@@ -5,7 +5,7 @@
  */
 import { type Discussion, type GossipDatabase } from '../db';
 import { IMessageProtocol } from '../api/messageProtocol';
-import { UserPublicKeys } from '#wasm';
+import { UserPublicKeys } from '../wasm/bindings';
 import { SessionModule } from '../wasm/session';
 import { GossipSdkEvents } from '../types/events';
 import { SdkConfig } from '../config/sdk';

package/dist/services/announcement.js

@@ -5,7 +5,7 @@
  */
 import { DiscussionStatus, DiscussionDirection, } from '../db';
 import { decodeUserId, encodeUserId } from '../utils/userId';
-import { SessionStatus } from '#wasm';
+import { SessionStatus } from '../wasm/bindings';
 import { sessionStatusToString } from '../wasm/session';
 import { Logger } from '../utils/logs';
 import { defaultSdkConfig } from '../config/sdk';

package/dist/services/auth.d.ts

@@ -3,7 +3,7 @@
  *
  * Handles storing and retrieving public keys by userId hash via the auth API.
  */
-import { UserPublicKeys } from '#wasm';
+import { UserPublicKeys } from '../wasm/bindings';
 import { IMessageProtocol } from '../api/messageProtocol/types';
 import { type GossipDatabase } from '../db';
 export type PublicKeyResult = {

package/dist/services/auth.js

@@ -3,7 +3,7 @@
  *
  * Handles storing and retrieving public keys by userId hash via the auth API.
  */
-import { UserPublicKeys } from '#wasm';
+import { UserPublicKeys } from '../wasm/bindings';
 import { decodeUserId } from '../utils/userId';
 import { encodeToBase64, decodeFromBase64 } from '../utils/base64';
 export class AuthService {

package/dist/services/discussion.js

@@ -4,7 +4,7 @@
  * Class-based service for initializing, accepting, and managing discussions.
  */
 import { DiscussionStatus, MessageDirection, MessageStatus, DiscussionDirection, } from '../db';
-import { UserPublicKeys, SessionStatus } from '#wasm';
+import { UserPublicKeys, SessionStatus } from '../wasm/bindings';
 import { EstablishSessionError } from './announcement';
 import { sessionStatusToString } from '../wasm/session';
 import { decodeUserId } from '../utils/userId';

package/dist/services/message.js

@@ -6,7 +6,7 @@
  */
 import { DiscussionStatus, MessageDirection, MessageStatus, MessageType, } from '../db';
 import { decodeUserId, encodeUserId } from '../utils/userId';
-import { SessionStatus } from '#wasm';
+import { SessionStatus } from '../wasm/bindings';
 import { serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, serializeKeepAliveMessage, deserializeMessage, } from '../utils/messageSerialization';
 import { encodeToBase64 } from '../utils/base64';
 import { sessionStatusToString } from '../wasm/session';

package/dist/services/refresh.js

@@ -6,7 +6,7 @@
  */
 import { MessageDirection, MessageStatus, MessageType, } from '../db';
 import { sessionStatusToString } from '../wasm/session';
-import { SessionStatus } from '#wasm';
+import { SessionStatus } from '../wasm/bindings';
 import { decodeUserId, encodeUserId } from '../utils/userId';
 import { Logger } from '../utils/logs';
 const logger = new Logger('RefreshService');

package/dist/wasm/bindings.d.ts

@@ -0,0 +1,9 @@
+/**
+ * WASM Bindings Barrel
+ *
+ * Re-exports all WASM-generated types and functions from the web target.
+ * This centralizes the WASM import so the rest of the codebase uses
+ * a standard relative import instead of conditional #wasm subpath imports.
+ */
+export { default as init } from '../assets/generated/wasm/gossip_wasm';
+export * from '../assets/generated/wasm/gossip_wasm';

package/dist/wasm/bindings.js

@@ -0,0 +1,9 @@
+/**
+ * WASM Bindings Barrel
+ *
+ * Re-exports all WASM-generated types and functions from the web target.
+ * This centralizes the WASM import so the rest of the codebase uses
+ * a standard relative import instead of conditional #wasm subpath imports.
+ */
+export { default as init } from '../assets/generated/wasm/gossip_wasm';
+export * from '../assets/generated/wasm/gossip_wasm';

package/dist/wasm/encryption.d.ts

@@ -5,7 +5,7 @@
  * and AEAD (Authenticated Encryption with Additional Data) operations,
  * ensuring proper initialization before calling any WASM functions.
  */
-import { EncryptionKey, Nonce } from '#wasm';
+import { EncryptionKey, Nonce } from './bindings';
 export { EncryptionKey, Nonce };
 /**
  * Generate a new random encryption key (64 bytes)

package/dist/wasm/encryption.js

@@ -6,7 +6,7 @@
  * ensuring proper initialization before calling any WASM functions.
  */
 import { ensureWasmInitialized } from './loader';
-import { EncryptionKey, Nonce, aead_encrypt as _aead_encrypt, aead_decrypt as _aead_decrypt, } from '#wasm';
+import { EncryptionKey, Nonce, aead_encrypt as _aead_encrypt, aead_decrypt as _aead_decrypt, } from './bindings';
 // Re-export classes
 export { EncryptionKey, Nonce };
 /**

package/dist/wasm/loader.d.ts

@@ -1,10 +1,10 @@
 /**
  * WASM Module Loader and Initialization Service
  *
- * This file handles WASM initialization. The actual wasm module is resolved
- * via the #wasm import which conditionally loads the correct target:
- * - Browser: web target (has init function, uses import.meta.url + fetch)
- * - Node: nodejs target (auto-initializes, no init function needed)
+ * This file handles WASM initialization. It uses a single web-target build
+ * and detects the runtime to load the WASM binary appropriately:
+ * - Browser: init() with no args (uses import.meta.url + fetch internally)
+ * - Node.js / Jiti: init(bytes) with WASM bytes read from the filesystem
  */
 /**
  * Initialize WASM modules if not already initialized

package/dist/wasm/loader.js

@@ -1,15 +1,12 @@
 /**
  * WASM Module Loader and Initialization Service
  *
- * This file handles WASM initialization. The actual wasm module is resolved
- * via the #wasm import which conditionally loads the correct target:
- * - Browser: web target (has init function, uses import.meta.url + fetch)
- * - Node: nodejs target (auto-initializes, no init function needed)
+ * This file handles WASM initialization. It uses a single web-target build
+ * and detects the runtime to load the WASM binary appropriately:
+ * - Browser: init() with no args (uses import.meta.url + fetch internally)
+ * - Node.js / Jiti: init(bytes) with WASM bytes read from the filesystem
  */
-import * as wasmModule from '#wasm';
-// The web target has a default export (init function), nodejs target doesn't
-const init = wasmModule
-    .default;
+import { init } from './bindings';
 /**
  * WASM Initialization State
  */
@@ -17,6 +14,14 @@ let isInitializing = false;
 let isInitialized = false;
 let initializationPromise = null;
 let initError = null;
+/**
+ * Detect if running in a Node.js-like environment (Node, Bun, Jiti, etc.)
+ */
+function isNodeRuntime() {
+    return (typeof process !== 'undefined' &&
+        process.versions != null &&
+        process.versions.node != null);
+}
 /**
  * Initialize WASM modules if not already initialized
  * This function is idempotent - safe to call multiple times
@@ -35,13 +40,21 @@ export async function initializeWasm() {
     initError = null;
     initializationPromise = (async () => {
         try {
-            // The #wasm import resolves to the correct target based on environment:
-            // - Browser (web target): has init() function that needs to be called
-            // - Node (nodejs target): auto-initializes on import, no init needed
-            if (typeof init === 'function') {
+            if (isNodeRuntime()) {
+                // Node.js / Jiti: read WASM bytes from filesystem and pass to init()
+                // Dynamic imports ensure these Node.js modules are tree-shaken in browser builds
+                const fs = await import('node:fs');
+                const url = await import('node:url');
+                const path = await import('node:path');
+                const currentDir = path.dirname(url.fileURLToPath(import.meta.url));
+                const wasmPath = path.resolve(currentDir, '../assets/generated/wasm/gossip_wasm_bg.wasm');
+                const wasmBytes = fs.readFileSync(wasmPath);
+                await init(wasmBytes);
+            }
+            else {
+                // Browser: use default loading (import.meta.url + fetch internally)
                 await init();
             }
-            // For nodejs target, wasm is already initialized on import
             isInitialized = true;
             isInitializing = false;
         }

package/dist/wasm/session.d.ts

@@ -4,7 +4,7 @@
  * This file contains the real WASM implementation of the SessionModule
  * using SessionManagerWrapper and related WASM classes.
  */
-import { UserPublicKeys, UserSecretKeys, ReceiveMessageOutput, SendMessageOutput, SessionStatus, EncryptionKey, SessionConfig, AnnouncementResult, UserKeys } from '#wasm';
+import { UserPublicKeys, UserSecretKeys, ReceiveMessageOutput, SendMessageOutput, SessionStatus, EncryptionKey, SessionConfig, AnnouncementResult, UserKeys } from './bindings';
 import { UserProfile } from '../db';
 export declare class SessionModule {
     private sessionManager;

package/dist/wasm/session.js

@@ -4,7 +4,7 @@
  * This file contains the real WASM implementation of the SessionModule
  * using SessionManagerWrapper and related WASM classes.
  */
-import { SessionManagerWrapper, SessionStatus, SessionConfig, } from '#wasm';
+import { SessionManagerWrapper, SessionStatus, SessionConfig, } from './bindings';
 import { encodeUserId } from '../utils/userId';
 export class SessionModule {
     constructor(userKeys, onPersist, config) {

package/dist/wasm/userKeys.d.ts

@@ -4,7 +4,7 @@
  * This file provides proxy functions for user key generation,
  * ensuring proper initialization before calling any WASM functions.
  */
-import { UserKeys } from '#wasm';
+import { UserKeys } from './bindings';
 export { UserKeys };
 /**
  * Generate user keys from a passphrase using password-based key derivation

package/dist/wasm/userKeys.js

@@ -5,7 +5,7 @@
  * ensuring proper initialization before calling any WASM functions.
  */
 import { ensureWasmInitialized } from './loader';
-import { generate_user_keys as _generate_user_keys, UserKeys } from '#wasm';
+import { generate_user_keys as _generate_user_keys, UserKeys, } from './bindings';
 // Re-export classes
 export { UserKeys };
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260130145448",
+  "version": "0.0.2-dev.20260210150149",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,12 +9,6 @@
     "dist",
     "README.md"
   ],
-  "imports": {
-    "#wasm": {
-      "browser": "./dist/assets/generated/wasm/gossip_wasm.js",
-      "default": "./dist/assets/generated/wasm-node/gossip_wasm.js"
-    }
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -28,11 +22,13 @@
   "scripts": {
     "prebuild": "rimraf dist",
     "build": "tsc && npm run copy:wasm",
-    "copy:wasm": "mkdir -p dist/assets/generated/wasm dist/assets/generated/wasm-node && cp -R src/assets/generated/wasm/* dist/assets/generated/wasm/ && cp -R src/assets/generated/wasm-node/* dist/assets/generated/wasm-node/",
+    "copy:wasm": "mkdir -p dist/assets/generated/wasm && cp -R src/assets/generated/wasm/* dist/assets/generated/wasm/",
     "test": "vitest",
     "test:run": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "test:e2e": "vitest run test/e2e/"
+    "test:e2e": "vitest run test/e2e/",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
   "keywords": [
     "gossip",

package/dist/assets/generated/wasm-node/README.md

@@ -1,281 +0,0 @@
-# Gossip WASM - WebAssembly Bindings
-
-This crate provides WebAssembly bindings for the Gossip secure messaging system, exposing the SessionManager and Auth facilities to JavaScript/TypeScript applications.
-
-## Features
-
-- **Session Management**: Create, persist, and manage encrypted messaging sessions
-- **Authentication**: Generate and manage cryptographic keys from passphrases
-- **Post-Quantum Security**: Uses ML-KEM and ML-DSA for quantum-resistant cryptography
-- **Encrypted State**: Secure serialization and deserialization of session state
-- **Seeker-based Addressing**: Messages use hashed Massa public keys for efficient lookups
-
-## Building
-
-### Prerequisites
-
-- Rust toolchain with `wasm32-unknown-unknown` target
-- wasm-pack (optional, for generating npm package)
-
-### Build with Cargo
-
-```bash
-cargo build --target wasm32-unknown-unknown --release
-```
-
-The compiled WASM module will be at:
-
-```
-../target/wasm32-unknown-unknown/release/gossip_wasm.wasm
-```
-
-### Build with wasm-pack
-
-For a complete npm-ready package with TypeScript definitions:
-
-```bash
-wasm-pack build --target web
-```
-
-## Usage
-
-### JavaScript/TypeScript
-
-```typescript
-import init, {
-  SessionManagerWrapper,
-  SessionConfig,
-  generate_user_keys,
-  EncryptionKey,
-} from './gossip_wasm';
-
-// Initialize WASM
-await init();
-
-// Generate user keys from passphrase
-const keys = generate_user_keys('my secure passphrase');
-const publicKeys = keys.public_keys();
-const secretKeys = keys.secret_keys();
-const userId = publicKeys.derive_id();
-
-// Create session manager with default configuration
-const config = SessionConfig.new_default();
-const manager = new SessionManagerWrapper(config);
-
-// Establish session with peer
-const peerKeys = generate_user_keys('peer passphrase');
-const userData = new TextEncoder().encode('contact_request'); // Optional user data
-const announcement = manager.establish_outgoing_session(
-  peerKeys.public_keys(),
-  publicKeys,
-  secretKeys,
-  userData
-);
-// Publish announcement to blockchain...
-
-// Feed incoming announcement from peer
-const result = manager.feed_incoming_announcement(
-  announcementBytes,
-  publicKeys,
-  secretKeys
-);
-if (result) {
-  console.log('Announcer public keys:', result.announcer_public_keys);
-  console.log('Timestamp:', result.timestamp);
-  console.log('User data:', new TextDecoder().decode(result.user_data));
-}
-
-// Send a message (raw bytes)
-const messageBytes = new TextEncoder().encode('Hello!');
-const peerId = peerKeys.public_keys().derive_id();
-const sendOutput = manager.send_message(peerId, messageBytes);
-if (sendOutput) {
-  // Publish sendOutput.seeker and sendOutput.data to blockchain
-  console.log('Seeker:', sendOutput.seeker);
-  console.log('Data length:', sendOutput.data.length);
-}
-
-// Check for incoming messages
-const seekers = manager.get_message_board_read_keys();
-for (let i = 0; i < seekers.length; i++) {
-  const seeker = seekers.get(i);
-  // Read from blockchain using seeker...
-  const received = manager.feed_incoming_message_board_read(
-    seeker,
-    data, // encrypted message data
-    secretKeys
-  );
-  if (received) {
-    console.log('Received:', new TextDecoder().decode(received.message));
-    console.log('Timestamp:', received.timestamp);
-    // Check acknowledged seekers
-    const acks = received.acknowledged_seekers;
-    for (let j = 0; j < acks.length; j++) {
-      console.log('Acknowledged:', acks.get(j));
-    }
-  }
-}
-
-// Persist session state
-const encryptionKey = EncryptionKey.generate();
-const encrypted = manager.to_encrypted_blob(encryptionKey);
-// Save encrypted blob to storage...
-
-// Restore session state
-const restored = SessionManagerWrapper.from_encrypted_blob(
-  encrypted,
-  encryptionKey
-);
-```
-
-### Custom Configuration
-
-```typescript
-const config = new SessionConfig(
-  604800000, // max_incoming_announcement_age_millis (1 week)
-  60000, // max_incoming_announcement_future_millis (1 minute)
-  604800000, // max_incoming_message_age_millis (1 week)
-  60000, // max_incoming_message_future_millis (1 minute)
-  604800000, // max_session_inactivity_millis (1 week)
-  86400000, // keep_alive_interval_millis (1 day)
-  10000 // max_session_lag_length
-);
-```
-
-## API Reference
-
-### AEAD Encryption Functions
-
-Direct access to AES-256-SIV authenticated encryption:
-
-- `aead_encrypt(key: EncryptionKey, nonce: Nonce, plaintext: Uint8Array, aad: Uint8Array)`: Encrypt data
-- `aead_decrypt(key: EncryptionKey, nonce: Nonce, ciphertext: Uint8Array, aad: Uint8Array)`: Decrypt data
-
-#### AEAD Example
-
-```typescript
-import {
-  EncryptionKey,
-  Nonce,
-  aead_encrypt,
-  aead_decrypt,
-} from './gossip_wasm';
-
-// Generate key and nonce
-const key = EncryptionKey.generate();
-const nonce = Nonce.generate();
-
-// Encrypt some data
-const plaintext = new TextEncoder().encode('Secret message');
-const aad = new TextEncoder().encode('context info'); // Additional authenticated data
-const ciphertext = aead_encrypt(key, nonce, plaintext, aad);
-
-// Decrypt
-const decrypted = aead_decrypt(key, nonce, ciphertext, aad);
-if (decrypted) {
-  console.log('Success:', new TextDecoder().decode(decrypted));
-} else {
-  console.error('Decryption failed - tampering detected!');
-}
-```
-
-**Security Notes:**
-
-- Nonces should be unique per encryption (16 bytes)
-- AAD (Additional Authenticated Data) is authenticated but NOT encrypted
-- AES-SIV is nonce-misuse resistant - reusing nonces only leaks if plaintexts are identical
-- Keys are 64 bytes (512 bits) for AES-256-SIV
-
-### SessionManagerWrapper
-
-Main class for managing messaging sessions.
-
-- `new(config: SessionConfig)`: Create new session manager
-- `from_encrypted_blob(blob: Uint8Array, key: EncryptionKey)`: Restore from encrypted state
-- `to_encrypted_blob(key: EncryptionKey)`: Serialize to encrypted blob
-- `establish_outgoing_session(peer_pk, our_pk, our_sk, user_data: Uint8Array)`: Initiate session with peer, including optional user data (returns announcement bytes)
-- `feed_incoming_announcement(bytes, our_pk, our_sk)`: Process incoming announcement (returns AnnouncementResult with announcer's public keys and user data, or undefined)
-- `send_message(peer_id: Uint8Array, message_contents: Uint8Array)`: Send raw message bytes to peer
-- `feed_incoming_message_board_read(seeker, data, our_sk)`: Process incoming messages
-- `get_message_board_read_keys()`: Get seekers to monitor for incoming messages
-- `peer_list()`: Get all peer IDs
-- `peer_session_status(peer_id: Uint8Array)`: Get session status
-- `peer_discard(peer_id: Uint8Array)`: Remove peer
-- `refresh()`: Refresh sessions and get keep-alive announcement list
-
-### AnnouncementResult
-
-Result from processing an incoming announcement:
-
-- `announcer_public_keys(): UserPublicKeys`: The public keys of the peer who sent the announcement
-- `timestamp(): number`: Unix timestamp in milliseconds when the announcement was created
-- `user_data(): Uint8Array`: Arbitrary user data embedded in the announcement (can be empty)
-
-**Use Cases for User Data:**
-
-- Contact requests with metadata
-- Version information
-- Application-specific handshake data
-- Display names or profile information
-- Protocol negotiation parameters
-
-**⚠️ Security Warning:**
-
-The user_data in announcements has **reduced security compared to regular messages**:
-
-- ✅ **Plausible deniability preserved**: The user_data is not cryptographically signed, so the sender can deny specific content
-- ❌ **No post-compromise secrecy**: If long-term keys are compromised, past announcements can be decrypted
-
-**Recommendation**: Use user_data for non-highly-sensitive metadata. Send truly sensitive information through regular messages after the session is established.
-
-### SendMessageOutput
-
-Output from sending a message:
-
-- `seeker(): Uint8Array`: Database key for message lookup on message board
-- `data(): Uint8Array`: Encrypted message data to publish
-- `timestamp(): number`: Message timestamp (milliseconds since Unix epoch)
-
-### ReceiveMessageOutput
-
-Output from receiving a message:
-
-- `message(): Uint8Array`: Decrypted message contents
-- `timestamp(): number`: Message timestamp (milliseconds since Unix epoch)
-- `acknowledged_seekers()`: Array of seekers that were acknowledged
-
-### Auth Functions
-
-- `generate_user_keys(passphrase: string)`: Generate keys from passphrase using password KDF
-
-### Other Classes
-
-- `SessionConfig`: Session manager configuration
-- `EncryptionKey`: AES-256-SIV key (64 bytes)
-  - `generate()`: Generate random key
-  - `from_bytes(bytes: Uint8Array)`: Create from bytes
-  - `to_bytes()`: Get raw bytes
-- `Nonce`: AES-256-SIV nonce (16 bytes)
-  - `generate()`: Generate random nonce
-  - `from_bytes(bytes: Uint8Array)`: Create from bytes
-  - `to_bytes()`: Get raw bytes
-- `UserPublicKeys`: User's public keys
-  - `derive_id()`: Get user ID (32 bytes)
-  - `to_bytes()`: Serialize to bytes
-- `UserSecretKeys`: User's secret keys
-- `SessionStatus`: Enum for session states (Active, Inactive, etc.)
-
-## Architecture
-
-The Gossip system uses a multi-layer architecture:
-
-1. **Crypto Primitives**: ML-KEM (post-quantum KEM), ML-DSA (post-quantum signatures), AES-SIV (AEAD)
-2. **Agraphon Protocol**: Double-ratchet encryption with forward secrecy and post-compromise security
-3. **Session Layer**: Manages Agraphon sessions with seeker-based addressing using hashed Massa public keys
-4. **Session Manager**: High-level API for multi-peer messaging with session lifecycle management
-
-Messages are identified by "seekers" - database keys derived from hashing ephemeral Massa public keys. This allows:
-
-- Efficient message lookup on public message boards
-- Privacy (seekers don't reveal sender/recipient identity)
-- Unlinkability (each message uses a fresh keypair)