@massalabs/gossip-sdk 0.0.2-dev.20260128111120 → 0.0.2-dev.20260128162527

package/dist/assets/generated/wasm-node/gossip_wasm_bg.wasm.d.ts

@@ -0,0 +1,164 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_announcementresult_free: (a: number, b: number) => void;
+export const __wbg_encryptionkey_free: (a: number, b: number) => void;
+export const __wbg_nonce_free: (a: number, b: number) => void;
+export const __wbg_receivemessageoutput_free: (a: number, b: number) => void;
+export const __wbg_sendmessageoutput_free: (a: number, b: number) => void;
+export const __wbg_sessionconfig_free: (a: number, b: number) => void;
+export const __wbg_sessionmanagerwrapper_free: (a: number, b: number) => void;
+export const __wbg_userkeys_free: (a: number, b: number) => void;
+export const __wbg_userpublickeys_free: (a: number, b: number) => void;
+export const __wbg_usersecretkeys_free: (a: number, b: number) => void;
+export const aead_decrypt: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number
+) => [number, number];
+export const aead_encrypt: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number
+) => [number, number];
+export const announcementresult_announcer_public_keys: (a: number) => number;
+export const announcementresult_timestamp: (a: number) => number;
+export const announcementresult_user_data: (a: number) => [number, number];
+export const encryptionkey_from_bytes: (
+  a: number,
+  b: number
+) => [number, number, number];
+export const encryptionkey_from_seed: (
+  a: number,
+  b: number,
+  c: number,
+  d: number
+) => [number, number, number];
+export const encryptionkey_generate: () => number;
+export const encryptionkey_to_bytes: (a: number) => [number, number];
+export const generate_user_keys: (
+  a: number,
+  b: number
+) => [number, number, number];
+export const nonce_from_bytes: (
+  a: number,
+  b: number
+) => [number, number, number];
+export const nonce_generate: () => number;
+export const nonce_to_bytes: (a: number) => [number, number];
+export const receivemessageoutput_acknowledged_seekers: (a: number) => any;
+export const receivemessageoutput_message: (a: number) => [number, number];
+export const receivemessageoutput_timestamp: (a: number) => number;
+export const receivemessageoutput_user_id: (a: number) => [number, number];
+export const sendmessageoutput_data: (a: number) => [number, number];
+export const sendmessageoutput_seeker: (a: number) => [number, number];
+export const sessionconfig_new: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number,
+  g: bigint
+) => number;
+export const sessionconfig_new_default: () => number;
+export const sessionmanagerwrapper_establish_outgoing_session: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number
+) => [number, number];
+export const sessionmanagerwrapper_feed_incoming_announcement: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number
+) => number;
+export const sessionmanagerwrapper_feed_incoming_message_board_read: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number,
+  f: number
+) => number;
+export const sessionmanagerwrapper_from_encrypted_blob: (
+  a: number,
+  b: number,
+  c: number
+) => [number, number, number];
+export const sessionmanagerwrapper_get_message_board_read_keys: (
+  a: number
+) => any;
+export const sessionmanagerwrapper_new: (a: number) => number;
+export const sessionmanagerwrapper_peer_discard: (
+  a: number,
+  b: number,
+  c: number
+) => [number, number];
+export const sessionmanagerwrapper_peer_list: (a: number) => any;
+export const sessionmanagerwrapper_peer_session_status: (
+  a: number,
+  b: number,
+  c: number
+) => [number, number, number];
+export const sessionmanagerwrapper_refresh: (a: number) => any;
+export const sessionmanagerwrapper_send_message: (
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  e: number
+) => [number, number, number];
+export const sessionmanagerwrapper_to_encrypted_blob: (
+  a: number,
+  b: number
+) => [number, number, number, number];
+export const userkeys_public_keys: (a: number) => [number, number, number];
+export const userkeys_secret_keys: (a: number) => [number, number, number];
+export const userpublickeys_derive_id: (a: number) => [number, number];
+export const userpublickeys_dsa_verification_key: (
+  a: number
+) => [number, number];
+export const userpublickeys_from_bytes: (
+  a: number,
+  b: number
+) => [number, number, number];
+export const userpublickeys_kem_public_key: (a: number) => [number, number];
+export const userpublickeys_massa_public_key: (a: number) => [number, number];
+export const userpublickeys_to_bytes: (
+  a: number
+) => [number, number, number, number];
+export const usersecretkeys_dsa_signing_key: (a: number) => [number, number];
+export const usersecretkeys_from_bytes: (
+  a: number,
+  b: number
+) => [number, number, number];
+export const usersecretkeys_kem_secret_key: (a: number) => [number, number];
+export const usersecretkeys_massa_secret_key: (a: number) => [number, number];
+export const usersecretkeys_to_bytes: (
+  a: number
+) => [number, number, number, number];
+export const start: () => void;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_export_2: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (
+  a: number,
+  b: number,
+  c: number,
+  d: number
+) => number;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/dist/assets/generated/wasm-node/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "gossip-wasm",
+  "version": "0.1.0",
+  "files": [
+    "gossip_wasm_bg.wasm",
+    "gossip_wasm.js",
+    "gossip_wasm.d.ts"
+  ],
+  "main": "gossip_wasm.js",
+  "types": "gossip_wasm.d.ts"
+}

package/dist/config/protocol.js

@@ -9,23 +9,29 @@
 const DEFAULT_API_URL = 'https://api.usegossip.com';
 // Mutable config that can be updated at runtime
 let currentBaseUrl = null;
+/**
+ * Safely get Vite environment variable without causing parse-time errors.
+ * Uses dynamic Function evaluation to avoid import.meta syntax errors
+ * in environments that don't support ESM (like jiti).
+ */
+function getViteEnvUrl() {
+    try {
+        // Use Function constructor to evaluate import.meta at runtime
+        // This avoids parse-time syntax errors in non-ESM environments
+        const fn = new Function('return typeof import.meta !== "undefined" && import.meta.env && import.meta.env.VITE_GOSSIP_API_URL');
+        return fn() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function buildProtocolApiBaseUrl() {
     // If runtime override is set, use it
     if (currentBaseUrl !== null) {
         return currentBaseUrl;
     }
-    // Try to get from environment variable (Vite)
-    let apiUrl;
-    try {
-        // Check if import.meta.env is available (Vite environment)
-        if (typeof import.meta !== 'undefined' &&
-            import.meta.env?.VITE_GOSSIP_API_URL) {
-            apiUrl = import.meta.env.VITE_GOSSIP_API_URL;
-        }
-    }
-    catch {
-        // import.meta.env not available (Node.js without Vite)
-    }
+    // Try to get from Vite environment variable
+    let apiUrl = getViteEnvUrl();
     // Check process.env for Node.js environment
     if (!apiUrl &&
         typeof process !== 'undefined' &&

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 './assets/generated/wasm/gossip_wasm';
+import type { UserPublicKeys } from '#wasm';
 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 './assets/generated/wasm/gossip_wasm';
+import type { UserPublicKeys } from '#wasm';
 import { type SdkEventType, type SdkEventHandlers } from './core/SdkEventEmitter';
 export type { SdkEventType, SdkEventHandlers };
 export interface GossipSdkInitOptions {

package/dist/index.d.ts

@@ -2,36 +2,23 @@
  * Gossip SDK
  *
  * Main entry point for the Gossip SDK.
- * Provides a platform-agnostic interface for automation, chatbot,
- * and integration use cases with the Gossip messenger.
+ * 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)
  *
  * @example
  * ```typescript
- * import { gossipSdk } from 'gossip-sdk';
- *
- * // Initialize once at app startup
- * await gossipSdk.init({
- *   db,
- *   protocolBaseUrl: 'https://api.example.com',
- * });
+ * import { gossipSdk } from '@massalabs/gossip-sdk';
  *
- * // Open session (login)
+ * await gossipSdk.init({ db, protocolBaseUrl: 'https://api.example.com' });
  * await gossipSdk.openSession({ mnemonic: '...' });
- *
- * // Use clean API
  * await gossipSdk.messages.send(contactId, 'Hello!');
- * await gossipSdk.discussions.start(contact);
- *
- * // Events
- * gossipSdk.on('message', (msg) => { ... });
- *
- * // Logout
- * await gossipSdk.closeSession();
  * ```
  *
  * @packageDocumentation
  */
-export declare const SDK_VERSION = "0.0.1";
 export { gossipSdk, GossipSdkImpl } from './gossipSdk';
 export type { GossipSdkInitOptions, OpenSessionOptions, SdkEventType, SdkEventHandlers, } from './gossipSdk';
 export type { GossipSdkEvents } from './types/events';
@@ -59,7 +46,7 @@ export { setDb, getDb, db, GossipDatabase } from './db';
 export { SessionModule, sessionStatusToString } from './wasm/session';
 export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from './wasm/loader';
 export { EncryptionKey, Nonce, generateEncryptionKey, generateEncryptionKeyFromSeed, encryptionKeyFromBytes, generateNonce, nonceFromBytes, encryptAead, decryptAead, } from './wasm/encryption';
-export { generateUserKeys } from './wasm/userKeys';
+export { generateUserKeys, UserKeys } from './wasm/userKeys';
 export { encodeUserId, decodeUserId, isValidUserId, formatUserId, generate as generateUserId, } from './utils/userId';
 export { validateUsernameFormat, validatePassword, validateUserIdFormat, validateUsernameAvailability, validateUsernameFormatAndAvailability, } from './utils/validation';
 export type { ValidationResult } from './utils/validation';
@@ -69,5 +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 './assets/generated/wasm/gossip_wasm';
-export { UserKeys } from './wasm/userKeys';
+export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from '#wasm';

package/dist/index.js

@@ -2,76 +2,60 @@
  * Gossip SDK
  *
  * Main entry point for the Gossip SDK.
- * Provides a platform-agnostic interface for automation, chatbot,
- * and integration use cases with the Gossip messenger.
+ * 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)
  *
  * @example
  * ```typescript
- * import { gossipSdk } from 'gossip-sdk';
- *
- * // Initialize once at app startup
- * await gossipSdk.init({
- *   db,
- *   protocolBaseUrl: 'https://api.example.com',
- * });
+ * import { gossipSdk } from '@massalabs/gossip-sdk';
  *
- * // Open session (login)
+ * await gossipSdk.init({ db, protocolBaseUrl: 'https://api.example.com' });
  * await gossipSdk.openSession({ mnemonic: '...' });
- *
- * // Use clean API
  * await gossipSdk.messages.send(contactId, 'Hello!');
- * await gossipSdk.discussions.start(contact);
- *
- * // Events
- * gossipSdk.on('message', (msg) => { ... });
- *
- * // Logout
- * await gossipSdk.closeSession();
  * ```
  *
  * @packageDocumentation
  */
-// SDK version - matches package.json
-export const SDK_VERSION = '0.0.1';
 // ─────────────────────────────────────────────────────────────────────────────
 // SDK Singleton - Primary API
 // ─────────────────────────────────────────────────────────────────────────────
 export { gossipSdk, GossipSdkImpl } from './gossipSdk';
-// Services - class-based with dependency injection
+// Services
 export { AuthService } from './services/auth';
 export { getPublicKeyErrorMessage, PUBLIC_KEY_NOT_FOUND_ERROR, PUBLIC_KEY_NOT_FOUND_MESSAGE, FAILED_TO_FETCH_ERROR, FAILED_TO_FETCH_MESSAGE, FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR, } from './services/auth';
 export { AnnouncementService, EstablishSessionError, } from './services/announcement';
 export { MessageService } from './services/message';
 export { DiscussionService } from './services/discussion';
 export { RefreshService } from './services/refresh';
-// Contact Management (utility functions)
+// Contact Management
 export { getContacts, getContact, addContact, updateContactName, deleteContact, } from './contacts';
 // Discussion utilities
 export { updateDiscussionName } from './utils/discussions';
-// Types - re-export all types from the types module
+// Types
 export * from './types';
-// Message Protocol - for direct use by host apps
+// Message Protocol
 export { createMessageProtocol, restMessageProtocol, RestMessageProtocol, MessageProtocol, } from './api/messageProtocol';
-// Config - for runtime configuration
+// Config
 export { setProtocolBaseUrl, resetProtocolBaseUrl, MessageProtocolType, protocolConfig, } from './config/protocol';
-// SDK Config - for SDK initialization options
 export { defaultSdkConfig, mergeConfig } from './config/sdk';
-// Database - for direct access by host apps
+// Database
 export { setDb, getDb, db, GossipDatabase } from './db';
-// WASM utilities - for session management
+// WASM utilities
 export { SessionModule, sessionStatusToString } from './wasm/session';
 export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from './wasm/loader';
 export { EncryptionKey, Nonce, generateEncryptionKey, generateEncryptionKeyFromSeed, encryptionKeyFromBytes, generateNonce, nonceFromBytes, encryptAead, decryptAead, } from './wasm/encryption';
-export { generateUserKeys } from './wasm/userKeys';
-// Utility functions - for direct use
+export { generateUserKeys, UserKeys } from './wasm/userKeys';
+// Utility functions
 export { encodeUserId, decodeUserId, isValidUserId, formatUserId, generate as generateUserId, } from './utils/userId';
 export { validateUsernameFormat, validatePassword, validateUserIdFormat, validateUsernameAvailability, validateUsernameFormatAndAvailability, } from './utils/validation';
 export { encodeToBase64, decodeFromBase64, encodeToBase64Url, decodeFromBase64Url, } from './utils/base64';
-// Message serialization utilities
+// Message serialization
 export { MESSAGE_TYPE_KEEP_ALIVE, serializeKeepAliveMessage, serializeRegularMessage, serializeReplyMessage, serializeForwardMessage, deserializeMessage, } from './utils/messageSerialization';
 // Crypto utilities
 export { generateMnemonic, validateMnemonic, mnemonicToSeed, accountFromMnemonic, PRIVATE_KEY_VERSION, } from './crypto/bip39';
 export { encrypt, decrypt, deriveKey } from './crypto/encryption';
-// WASM types and functions re-exported for convenience
-export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from './assets/generated/wasm/gossip_wasm';
-export { UserKeys } from './wasm/userKeys';
+// WASM types re-exported for convenience
+export { UserPublicKeys, UserSecretKeys, SessionStatus, SessionConfig, SessionManagerWrapper, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, generate_user_keys, } from '#wasm';

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 '../assets/generated/wasm/gossip_wasm';
+import { UserPublicKeys } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { SessionStatus } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { UserPublicKeys } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { UserPublicKeys } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { UserPublicKeys, SessionStatus } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { SessionStatus } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { SessionStatus } from '#wasm';
 import { decodeUserId, encodeUserId } from '../utils/userId';
 import { Logger } from '../utils/logs';
 const logger = new Logger('RefreshService');

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 '../assets/generated/wasm/gossip_wasm';
+import { EncryptionKey, Nonce } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { EncryptionKey, Nonce, aead_encrypt as _aead_encrypt, aead_decrypt as _aead_decrypt, } from '#wasm';
 // Re-export classes
 export { EncryptionKey, Nonce };
 /**

package/dist/wasm/loader.d.ts

@@ -1,9 +1,10 @@
 /**
  * WASM Module Loader and Initialization Service
  *
- * This file handles both WASM core initialization and module loading.
- * It ensures WASM modules are initialized once and properly throughout
- * the application lifecycle.
+ * 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)
  */
 /**
  * Initialize WASM modules if not already initialized

package/dist/wasm/loader.js

@@ -1,38 +1,15 @@
 /**
  * WASM Module Loader and Initialization Service
  *
- * This file handles both WASM core initialization and module loading.
- * It ensures WASM modules are initialized once and properly throughout
- * the application lifecycle.
+ * 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)
  */
-import init from '../assets/generated/wasm/gossip_wasm';
-/**
- * Check if we're running in Node.js environment
- */
-function isNodeEnvironment() {
-    return (typeof process !== 'undefined' &&
-        process.versions != null &&
-        process.versions.node != null);
-}
-/**
- * Load WASM module for Node.js environment using fs.readFileSync
- */
-async function loadWasmForNode() {
-    // Dynamic import to avoid bundling Node.js modules in browser builds
-    const fs = await import('node:fs');
-    const path = await import('node:path');
-    const { fileURLToPath } = await import('node:url');
-    // Get the directory of the current module
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    // Resolve path to WASM file - WASM is in the SDK's generated folder
-    const wasmPath = path.resolve(__dirname, '../assets/generated/wasm/gossip_wasm_bg.wasm');
-    // Read WASM file as binary
-    const wasmBuffer = fs.readFileSync(wasmPath);
-    // Instantiate WASM module
-    const wasmModule = await WebAssembly.compile(wasmBuffer);
-    return wasmModule;
-}
+import * as wasmModule from '#wasm';
+// The web target has a default export (init function), nodejs target doesn't
+const init = wasmModule
+    .default;
 /**
  * WASM Initialization State
  */
@@ -58,15 +35,13 @@ export async function initializeWasm() {
     initError = null;
     initializationPromise = (async () => {
         try {
-            // In Node.js environment, load WASM using fs.readFileSync
-            if (isNodeEnvironment()) {
-                const wasmModule = await loadWasmForNode();
-                await init(wasmModule);
-            }
-            else {
-                // In browser/jsdom, use default init (which uses fetch)
+            // 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') {
                 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 '../assets/generated/wasm/gossip_wasm';
+import { UserPublicKeys, UserSecretKeys, ReceiveMessageOutput, SendMessageOutput, SessionStatus, EncryptionKey, SessionConfig, AnnouncementResult, UserKeys } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { SessionManagerWrapper, SessionStatus, SessionConfig, } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { UserKeys } from '#wasm';
 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 '../assets/generated/wasm/gossip_wasm';
+import { generate_user_keys as _generate_user_keys, UserKeys } from '#wasm';
 // Re-export classes
 export { UserKeys };
 /**