@massalabs/gossip-sdk 0.0.2-dev.20260226131013 → 0.0.2-dev.20260302112618

package/dist/config/sdk.d.ts

@@ -57,6 +57,17 @@ export interface AnnouncementsConfig {
     /** Delay before retrying a failed announcement send in ms (default: 15000 = 15 seconds) */
     retryDelayMs: number;
 }
+/**
+ * Session recovery configuration
+ */
+export interface SessionRecoveryConfig {
+    /** Delay before retrying a killed session reset (default: 15 minutes) */
+    killedRetryDelayMs: number;
+    /** Jitter applied (default: 2 minutes) */
+    JitterMs: number;
+    /** Delay before retrying a saturated session reset (default: 5 minutes) */
+    saturatedRetryDelayMs: number;
+}
 /**
  * Complete SDK configuration
  */
@@ -69,6 +80,8 @@ export interface SdkConfig {
     messages: MessagesConfig;
     /** Announcement settings */
     announcements: AnnouncementsConfig;
+    /** Session recovery settings */
+    sessionRecovery: SessionRecoveryConfig;
 }
 /**
  * Default SDK configuration values

package/dist/config/sdk.js

@@ -29,6 +29,11 @@ export const defaultSdkConfig = {
         brokenThresholdMs: 60 * 60 * 1000, // 1 hour
         retryDelayMs: 15000, // 15 seconds
     },
+    sessionRecovery: {
+        killedRetryDelayMs: 15 * 60 * 1000,
+        JitterMs: 2 * 60 * 1000,
+        saturatedRetryDelayMs: 5 * 60 * 1000,
+    },
 };
 /**
  * Deep merge partial config with defaults
@@ -53,5 +58,9 @@ export function mergeConfig(partial) {
             ...defaultSdkConfig.announcements,
             ...partial.announcements,
         },
+        sessionRecovery: {
+            ...defaultSdkConfig.sessionRecovery,
+            ...partial.sessionRecovery,
+        },
     };
 }

package/dist/core/SdkEventEmitter.d.ts

@@ -3,7 +3,8 @@
  *
  * Type-safe event emitter for SDK events.
  */
-import type { Message, Discussion, Contact } from '../db/index.js';
+import type { Message, Discussion, Contact } from '../db';
+import type { SessionStatus } from '../wasm/bindings';
 export declare enum SdkEventType {
     MESSAGE_RECEIVED = "messageReceived",
     MESSAGE_SENT = "messageSent",
@@ -14,6 +15,7 @@ export declare enum SdkEventType {
     SESSION_RENEWED = "sessionRenewed",
     SESSION_ACCEPTED = "sessionAccepted",
     SEEKERS_UPDATED = "seekersUpdated",
+    SESSION_STATUS_CHANGED = "sessionStatusChanged",
     ERROR = "error"
 }
 export interface SdkEventHandlers {
@@ -26,6 +28,7 @@ export interface SdkEventHandlers {
     [SdkEventType.SESSION_RENEWED]: (discussion: Discussion) => void;
     [SdkEventType.SESSION_ACCEPTED]: (contactUserId: string) => void;
     [SdkEventType.SEEKERS_UPDATED]: (seekers: Uint8Array[]) => void;
+    [SdkEventType.SESSION_STATUS_CHANGED]: (contactUserId: string, status: SessionStatus) => void;
     [SdkEventType.ERROR]: (error: Error, context: string) => void;
 }
 export declare class SdkEventEmitter {

package/dist/core/SdkEventEmitter.js

@@ -17,6 +17,7 @@ export var SdkEventType;
     SdkEventType["SESSION_RENEWED"] = "sessionRenewed";
     SdkEventType["SESSION_ACCEPTED"] = "sessionAccepted";
     SdkEventType["SEEKERS_UPDATED"] = "seekersUpdated";
+    SdkEventType["SESSION_STATUS_CHANGED"] = "sessionStatusChanged";
     SdkEventType["ERROR"] = "error";
 })(SdkEventType || (SdkEventType = {}));
 // ─────────────────────────────────────────────────────────────────────────────
@@ -38,6 +39,7 @@ export class SdkEventEmitter {
                 [SdkEventType.SESSION_RENEWED]: new Set(),
                 [SdkEventType.SESSION_ACCEPTED]: new Set(),
                 [SdkEventType.SEEKERS_UPDATED]: new Set(),
+                [SdkEventType.SESSION_STATUS_CHANGED]: new Set(),
                 [SdkEventType.ERROR]: new Set(),
             }
         });

package/dist/core/SdkPolling.d.ts

@@ -12,6 +12,8 @@ export interface PollingCallbacks {
     fetchAnnouncements: () => Promise<void>;
     /** Handle session refresh (state update) */
     handleSessionRefresh: () => Promise<void>;
+    /** Check for session status changes and emit events */
+    refreshSessionsStatusEvent: () => Promise<void>;
 }
 export declare class SdkPolling {
     private timers;

package/dist/core/SdkPolling.js

@@ -4,6 +4,7 @@
  * Manages polling timers for messages, announcements, and session refresh.
  */
 import { SdkEventType } from './SdkEventEmitter.js';
+const SESSION_STATUS_POLL_INTERVAL_MS = 3000;
 // ─────────────────────────────────────────────────────────────────────────────
 // Polling Manager Class
 // ─────────────────────────────────────────────────────────────────────────────
@@ -17,6 +18,7 @@ export class SdkPolling {
                 messages: null,
                 announcements: null,
                 sessionRefresh: null,
+                sessionStatus: null,
             }
         });
         Object.defineProperty(this, "callbacks", {
@@ -75,6 +77,16 @@ export class SdkPolling {
                 this.eventEmitter?.emit(SdkEventType.ERROR, err, 'session_update');
             }
         }, config.polling.sessionRefreshIntervalMs);
+        // Start session status change polling (fixed 3s interval)
+        this.timers.sessionStatus = setInterval(async () => {
+            try {
+                await this.callbacks?.refreshSessionsStatusEvent();
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.eventEmitter?.emit(SdkEventType.ERROR, err, 'session_status_polling');
+            }
+        }, SESSION_STATUS_POLL_INTERVAL_MS);
     }
     /**
      * Stop all polling timers.
@@ -92,6 +104,10 @@ export class SdkPolling {
             clearInterval(this.timers.sessionRefresh);
             this.timers.sessionRefresh = null;
         }
+        if (this.timers.sessionStatus) {
+            clearInterval(this.timers.sessionStatus);
+            this.timers.sessionStatus = null;
+        }
         this.callbacks = null;
         this.eventEmitter = null;
     }
@@ -101,6 +117,7 @@ export class SdkPolling {
     isRunning() {
         return (this.timers.messages !== null ||
             this.timers.announcements !== null ||
-            this.timers.sessionRefresh !== null);
+            this.timers.sessionRefresh !== null ||
+            this.timers.sessionStatus !== null);
     }
 }

package/dist/db/db.d.ts

@@ -65,14 +65,6 @@ export interface UserProfile {
     updatedAt: Date;
     lastPublicKeyPush?: Date;
 }
-export declare enum DiscussionStatus {
-    PENDING = "pending",
-    ACTIVE = "active",
-    CLOSED = "closed",// closed by the user
-    BROKEN = "broken",// The session is killed. Need to be reinitiated
-    SEND_FAILED = "sendFailed",// The discussion was initiated by the session manager but could not be broadcasted on network
-    RECONNECTING = "reconnecting"
-}
 export declare enum DiscussionDirection {
     RECEIVED = "received",
     INITIATED = "initiated"
@@ -128,7 +120,6 @@ export interface Discussion {
     weAccepted: boolean;
     sendAnnouncement: SendAnnouncement;
     direction: DiscussionDirection;
-    status: DiscussionStatus;
     nextSeeker: Uint8Array | null;
     initiationAnnouncement: Uint8Array | null;
     announcementMessage: string | null;
@@ -139,6 +130,9 @@ export interface Discussion {
     lastMessageContent: string | null;
     lastMessageTimestamp: Date | null;
     unreadCount: number;
+    killedNextRetryAt?: Date | null;
+    saturatedRetryAt?: Date | null;
+    saturatedRetryDone: boolean;
     createdAt: Date;
     updatedAt: Date;
 }

package/dist/db/db.js

@@ -7,15 +7,6 @@
 // Constants
 export const MESSAGE_ID_SIZE = 12;
 // Unified discussion interface combining protocol state and UI metadata
-export var DiscussionStatus;
-(function (DiscussionStatus) {
-    DiscussionStatus["PENDING"] = "pending";
-    DiscussionStatus["ACTIVE"] = "active";
-    DiscussionStatus["CLOSED"] = "closed";
-    DiscussionStatus["BROKEN"] = "broken";
-    DiscussionStatus["SEND_FAILED"] = "sendFailed";
-    DiscussionStatus["RECONNECTING"] = "reconnecting";
-})(DiscussionStatus || (DiscussionStatus = {}));
 export var DiscussionDirection;
 (function (DiscussionDirection) {
     DiscussionDirection["RECEIVED"] = "received";

package/dist/db/generated-migrations.js

@@ -4,7 +4,7 @@ export const MIGRATIONS = [
     {
         idx: 0,
         tag: '0000_nifty_molly_hayes',
-        when: 1771825473415,
+        when: 1730000000000,
         statements: [
             'CREATE TABLE `activeSeekers` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`seeker` blob NOT NULL\n);',
             'CREATE INDEX `active_seekers_seeker_idx` ON `activeSeekers` (`seeker`);',
@@ -12,9 +12,8 @@ export const MIGRATIONS = [
             'CREATE TABLE `contacts` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`userId` text NOT NULL,\n\t`name` text NOT NULL,\n\t`avatar` text,\n\t`publicKeys` blob NOT NULL,\n\t`isOnline` integer NOT NULL,\n\t`lastSeen` integer NOT NULL,\n\t`createdAt` integer NOT NULL\n);',
             'CREATE INDEX `contacts_owner_user_idx` ON `contacts` (`ownerUserId`,`userId`);',
             'CREATE INDEX `contacts_owner_name_idx` ON `contacts` (`ownerUserId`,`name`);',
-            'CREATE TABLE `discussions` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`weAccepted` integer DEFAULT false NOT NULL,\n\t`sendAnnouncement` text,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`nextSeeker` blob,\n\t`initiationAnnouncement` blob,\n\t`announcementMessage` text,\n\t`lastSyncTimestamp` integer,\n\t`customName` text,\n\t`lastMessageId` integer,\n\t`lastMessageContent` text,\n\t`lastMessageTimestamp` integer,\n\t`unreadCount` integer DEFAULT 0 NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL\n);',
+            'CREATE TABLE `discussions` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`weAccepted` integer DEFAULT false NOT NULL,\n\t`sendAnnouncement` text,\n\t`direction` text NOT NULL,\n\t`nextSeeker` blob,\n\t`initiationAnnouncement` blob,\n\t`announcementMessage` text,\n\t`lastSyncTimestamp` integer,\n\t`customName` text,\n\t`lastMessageId` integer,\n\t`lastMessageContent` text,\n\t`lastMessageTimestamp` integer,\n\t`unreadCount` integer DEFAULT 0 NOT NULL,\n\t`killedNextRetryAt` integer,\n\t`saturatedRetryAt` integer,\n\t`saturatedRetryDone` integer DEFAULT 0 NOT NULL,\n\t`createdAt` integer NOT NULL,\n\t`updatedAt` integer NOT NULL\n);',
             'CREATE UNIQUE INDEX `discussions_owner_contact_idx` ON `discussions` (`ownerUserId`,`contactUserId`);',
-            'CREATE INDEX `discussions_owner_status_idx` ON `discussions` (`ownerUserId`,`status`);',
             'CREATE TABLE `messages` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`ownerUserId` text NOT NULL,\n\t`contactUserId` text NOT NULL,\n\t`messageId` blob,\n\t`content` text NOT NULL,\n\t`serializedContent` blob,\n\t`type` text NOT NULL,\n\t`direction` text NOT NULL,\n\t`status` text NOT NULL,\n\t`timestamp` integer NOT NULL,\n\t`metadata` text,\n\t`seeker` blob,\n\t`replyTo` text,\n\t`forwardOf` text,\n\t`encryptedMessage` blob,\n\t`whenToSend` integer\n);',
             'CREATE INDEX `messages_owner_contact_idx` ON `messages` (`ownerUserId`,`contactUserId`);',
             'CREATE INDEX `messages_owner_status_idx` ON `messages` (`ownerUserId`,`status`);',
@@ -23,6 +22,7 @@ export const MIGRATIONS = [
             'CREATE INDEX `messages_owner_contact_dir_idx` ON `messages` (`ownerUserId`,`contactUserId`,`direction`);',
             'CREATE INDEX `messages_owner_dir_status_idx` ON `messages` (`ownerUserId`,`direction`,`status`);',
             'CREATE INDEX `messages_timestamp_idx` ON `messages` (`timestamp`);',
+            'CREATE INDEX `messages_owner_contact_msgid_idx` ON `messages` (`ownerUserId`,`contactUserId`,`messageId`);',
             'CREATE TABLE `pendingAnnouncements` (\n\t`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,\n\t`announcement` blob NOT NULL,\n\t`fetchedAt` integer NOT NULL,\n\t`counter` text\n);',
             'CREATE UNIQUE INDEX `pending_announcements_announcement_idx` ON `pendingAnnouncements` (`announcement`);',
             'CREATE INDEX `pending_announcements_fetchedAt_idx` ON `pendingAnnouncements` (`fetchedAt`);',
@@ -34,12 +34,4 @@ export const MIGRATIONS = [
             'CREATE INDEX `userProfile_status_idx` ON `userProfile` (`status`);',
         ],
     },
-    {
-        idx: 1,
-        tag: '0001_flowery_storm',
-        when: 1771827090330,
-        statements: [
-            'CREATE INDEX `messages_owner_contact_msgid_idx` ON `messages` (`ownerUserId`,`contactUserId`,`messageId`);',
-        ],
-    },
 ];

package/dist/db/queries/discussions.d.ts

@@ -1,8 +1,7 @@
 import * as schema from '../schema/index.js';
 import type { DatabaseConnection } from '../sqlite.js';
-import type { DiscussionStatus } from '../db';
 export type DiscussionRow = typeof schema.discussions.$inferSelect;
-type DiscussionInsert = typeof schema.discussions.$inferInsert;
+export type DiscussionInsert = typeof schema.discussions.$inferInsert;
 export declare class DiscussionQueries {
     private conn;
     constructor(conn: DatabaseConnection);
@@ -15,6 +14,4 @@ export declare class DiscussionQueries {
     deleteByOwnerAndContact(ownerUserId: string, contactUserId: string): Promise<void>;
     incrementUnreadCount(discussionId: number): Promise<void>;
     decrementUnreadCount(discussionId: number): Promise<void>;
-    getByOwnerAndStatus(ownerUserId: string, status: DiscussionStatus): Promise<DiscussionRow[]>;
 }
-export {};

package/dist/db/queries/discussions.js

@@ -66,11 +66,4 @@ export class DiscussionQueries {
         })
             .where(and(eq(schema.discussions.id, discussionId), gt(schema.discussions.unreadCount, 0)));
     }
-    async getByOwnerAndStatus(ownerUserId, status) {
-        return this.conn.db
-            .select()
-            .from(schema.discussions)
-            .where(and(eq(schema.discussions.ownerUserId, ownerUserId), eq(schema.discussions.status, status)))
-            .all();
-    }
 }

package/dist/db/schema/discussions.d.ts

@@ -1,4 +1,4 @@
-import type { DiscussionDirection, DiscussionStatus } from '../db';
+import type { DiscussionDirection } from '../db';
 export declare const discussions: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "discussions";
     schema: undefined;
@@ -114,26 +114,6 @@ export declare const discussions: import("drizzle-orm/sqlite-core").SQLiteTableW
             length: number | undefined;
             $type: DiscussionDirection;
         }>;
-        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "status";
-            tableName: "discussions";
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: DiscussionStatus;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: number | undefined;
-            $type: DiscussionStatus;
-        }>;
         nextSeeker: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "nextSeeker";
             tableName: "discussions";
@@ -297,6 +277,57 @@ export declare const discussions: import("drizzle-orm/sqlite-core").SQLiteTableW
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        killedNextRetryAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "killedNextRetryAt";
+            tableName: "discussions";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        saturatedRetryAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "saturatedRetryAt";
+            tableName: "discussions";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        saturatedRetryDone: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "saturatedRetryDone";
+            tableName: "discussions";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "createdAt";
             tableName: "discussions";

package/dist/db/schema/discussions.js

@@ -1,4 +1,4 @@
-import { sqliteTable, text, integer, index, uniqueIndex, } from 'drizzle-orm/sqlite-core';
+import { sqliteTable, text, integer, uniqueIndex, } from 'drizzle-orm/sqlite-core';
 import { bytes } from './_helpers.js';
 export const discussions = sqliteTable('discussions', {
     id: integer('id').primaryKey({ autoIncrement: true }),
@@ -9,7 +9,6 @@ export const discussions = sqliteTable('discussions', {
         .default(false),
     sendAnnouncement: text('sendAnnouncement'),
     direction: text('direction').$type().notNull(),
-    status: text('status').$type().notNull(),
     nextSeeker: bytes('nextSeeker'),
     initiationAnnouncement: bytes('initiationAnnouncement'),
     announcementMessage: text('announcementMessage'),
@@ -23,9 +22,13 @@ export const discussions = sqliteTable('discussions', {
         mode: 'timestamp_ms',
     }),
     unreadCount: integer('unreadCount').notNull().default(0),
+    killedNextRetryAt: integer('killedNextRetryAt', { mode: 'timestamp_ms' }),
+    saturatedRetryAt: integer('saturatedRetryAt', { mode: 'timestamp_ms' }),
+    saturatedRetryDone: integer('saturatedRetryDone', { mode: 'boolean' })
+        .notNull()
+        .default(false),
     createdAt: integer('createdAt', { mode: 'timestamp_ms' }).notNull(),
     updatedAt: integer('updatedAt', { mode: 'timestamp_ms' }).notNull(),
 }, table => [
     uniqueIndex('discussions_owner_contact_idx').on(table.ownerUserId, table.contactUserId),
-    index('discussions_owner_status_idx').on(table.ownerUserId, table.status),
 ]);

package/dist/db/sqlite-worker.js

@@ -14,6 +14,9 @@ import * as SQLite from 'wa-sqlite';
 import { execStatements } from './exec-utils.js';
 let sqlite3 = null;
 let dbHandle = null;
+// Add a message queue to process messages sequentially
+const messageQueue = [];
+let processing = false;
 // Bind Worker's postMessage (avoids DOM lib signature mismatch at compile time)
 const post = globalThis.postMessage.bind(globalThis);
 async function execSql(sql, params) {
@@ -28,7 +31,22 @@ async function execSql(sql, params) {
     }
     return { rows, lastInsertRowId };
 }
-addEventListener('message', async (e) => {
+// Ensure that all messages are processed sequentially to avoid
+// concurrent access to the underlying WASM/SQLite state, which
+// can lead to heap corruption and "index out of bounds"/
+// "unreachable executed" errors.
+async function processMessageQueue() {
+    if (processing || messageQueue.length === 0)
+        return;
+    processing = true;
+    while (messageQueue.length > 0) {
+        const { e, resolve } = messageQueue.shift();
+        await handleMessage(e);
+        resolve();
+    }
+    processing = false;
+}
+async function handleMessage(e) {
     const { id, type } = e.data;
     try {
         switch (type) {
@@ -87,4 +105,13 @@ addEventListener('message', async (e) => {
     catch (err) {
         post({ id, type: 'error', message: err.message });
     }
+}
+addEventListener('message', (e) => {
+    // Chain each message onto the promise queue so that messages
+    // are handled strictly one after another.
+    let resolve;
+    const promise = new Promise(r => (resolve = r));
+    messageQueue.push({ e, resolve });
+    promise.then(() => processMessageQueue());
+    processMessageQueue();
 });

package/dist/gossip.js

@@ -233,7 +233,7 @@ class GossipSdk {
         this._announcement = new AnnouncementService(messageProtocol, session, this.eventEmitter, config, queries);
         this._discussion = new DiscussionService(this._announcement, session, this.eventEmitter, queries);
         this._message = new MessageService(messageProtocol, session, this.eventEmitter, config, queries);
-        this._refresh = new RefreshService(this._message, this._discussion, this._announcement, session, this.eventEmitter, queries);
+        this._refresh = new RefreshService(this._message, this._discussion, this._announcement, session, this.eventEmitter, queries, this.config);
         // Publish gossip ID (public key) on messageProtocol so the user is discoverable
         await this._auth.ensurePublicKeyPublished(session.ourPk, session.userIdEncoded);
         // Now set refreshService on services (circular dependency resolved via setter)
@@ -470,6 +470,9 @@ class GossipSdk {
             handleSessionRefresh: async () => {
                 await this.updateState();
             },
+            refreshSessionsStatusEvent: async () => {
+                await this._refresh?.refreshSessionsStatusEvent();
+            },
         }, this.eventEmitter);
     }
     // ─────────────────────────────────────────────────────────────────

package/dist/services/announcement.js

@@ -3,7 +3,7 @@
  *
  * Handles broadcasting and processing of session announcements.
  */
-import { DiscussionDirection, DiscussionStatus, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db/index.js';
+import { DiscussionDirection, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db/index.js';
 import { toDiscussion } from '../utils/discussions.js';
 import { decodeUserId, encodeUserId } from '../utils/userId.js';
 import { SessionStatus } from '../wasm/bindings.js';
@@ -153,6 +153,9 @@ export class AnnouncementService {
                         when_to_send: new Date(Date.now() + this.config.announcements.retryDelayMs),
                     }),
                     updatedAt: new Date(),
+                    /* If send announcement failed, There are chances that the session will be killed again the next state_update call.
+                    We don't want to wait a delay before reseting the session so we set killedNextRetryAt to null*/
+                    killedNextRetryAt: null,
                 });
             }
         }
@@ -432,7 +435,6 @@ export class AnnouncementService {
             ownerUserId,
             contactUserId,
             direction: DiscussionDirection.RECEIVED,
-            status: DiscussionStatus.PENDING,
             announcementMessage: message,
             unreadCount: 0,
             createdAt: new Date(),

package/dist/services/discussion.js

@@ -3,7 +3,7 @@
  *
  * Class-based service for initializing, accepting, and managing discussions.
  */
-import { DiscussionDirection, DiscussionStatus, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db/index.js';
+import { DiscussionDirection, MessageDirection, MessageStatus, MessageType, serializeSendAnnouncement, } from '../db/index.js';
 import { toDiscussion, toSortedDiscussions, updateDiscussionName, } from '../utils/discussions.js';
 import { encodeAnnouncementPayload, } from '../utils/announcementPayload.js';
 import { UserPublicKeys } from '../wasm/bindings.js';
@@ -113,7 +113,6 @@ export class DiscussionService {
                 contactUserId: contact.userId,
                 weAccepted: true,
                 direction: DiscussionDirection.INITIATED,
-                status: DiscussionStatus.PENDING,
                 unreadCount: 0,
                 createdAt: new Date(),
                 updatedAt: new Date(),

package/dist/services/message.js

@@ -581,14 +581,19 @@ export class MessageService {
             }
             const peerId = decodeUserId(contactUserId);
             const sessionStatus = this.session.peerSessionStatus(peerId);
-            if (sessionStatus !== SessionStatus.Active) {
-                log.info('session not active, skipping send queue', {
+            if (![
+                SessionStatus.Active,
+                // saturated sessions can't send messages on session manager but it's still possible to send on network msg that have already been encrypted if any
+                SessionStatus.Saturated,
+            ].includes(sessionStatus)) {
+                log.info('session neither active nor saturated, skipping send queue', {
                     contactUserId,
                     sessionStatus: sessionStatusToString(sessionStatus),
                 });
-                // Not an error: queued messages should remain pending until the
-                // handshake reaches Active.
-                return { success: true, data: 0 };
+                return {
+                    success: false,
+                    error: new Error('Session neither active nor saturated'),
+                };
             }
             // retrieve all messages in send queue that need to be updated for this contact
             const pendingMessages = (await this.queries.messages.getSendQueue(ownerUserId, contactUserId)).map(rowToMessage);
@@ -613,7 +618,9 @@ export class MessageService {
                 let encryptedMessage = msg.encryptedMessage;
                 let seeker = msg.seeker;
                 let whenToSend = msg.whenToSend;
-                if (currentStatus === MessageStatus.WAITING_SESSION) {
+                // If the sessions is saturated it can't send messages on session manager
+                if (currentStatus === MessageStatus.WAITING_SESSION &&
+                    sessionStatus === SessionStatus.Active) {
                     let serializedContent = msg.serializedContent;
                     if (!serializedContent) {
                         const serializeResult = await this.serializeMessage(msg);

package/dist/services/refresh.d.ts

@@ -4,12 +4,13 @@
  * Class-based service to periodically refresh sessions and handle
  * keep-alive messages and broken sessions.
  */
+import { type Queries } from '../db/index.js';
 import type { SessionModule } from '../wasm/session.js';
 import { MessageService } from './message.js';
 import { AnnouncementService } from './announcement.js';
 import { DiscussionService } from './discussion.js';
 import { SdkEventEmitter } from '../core/SdkEventEmitter.js';
-import { Queries } from '../db/queries/index.js';
+import type { SdkConfig } from '../config/sdk.js';
 /**
  * Service for refreshing sessions and handling keep-alive messages.
  *
@@ -35,7 +36,14 @@ export declare class RefreshService {
     private isUpdating;
     private eventEmitter;
     private queries;
-    constructor(messageService: MessageService, discussionService: DiscussionService, announcementService: AnnouncementService, session: SessionModule, eventEmitter: SdkEventEmitter, queries: Queries);
+    private config;
+    private sessionStatusMap;
+    constructor(messageService: MessageService, discussionService: DiscussionService, announcementService: AnnouncementService, session: SessionModule, eventEmitter: SdkEventEmitter, queries: Queries, config: SdkConfig);
+    /**
+     * Emit sessionStatusChanged events for discussions whose session status
+     * has changed since the last check.
+     */
+    refreshSessionsStatusEvent(): Promise<void>;
     /**
      * Update state for all discussions:
      * - Cleanup orphaned peers
@@ -46,4 +54,7 @@ export declare class RefreshService {
      * @param discussions - Array of discussions to process
      */
     stateUpdate(): Promise<void>;
+    private getJitteredDelayMs;
+    private updateSessionRecovery;
+    private handleSessionStatus;
 }

package/dist/services/refresh.js

@@ -4,7 +4,7 @@
  * Class-based service to periodically refresh sessions and handle
  * keep-alive messages and broken sessions.
  */
-import { MessageType, MessageDirection, MessageStatus } from '../db/index.js';
+import { MessageDirection, MessageStatus, MessageType, } from '../db/index.js';
 import { toSortedDiscussions } from '../utils/discussions.js';
 import { SessionStatus } from '../wasm/bindings.js';
 import { decodeUserId, encodeUserId } from '../utils/userId.js';
@@ -29,7 +29,7 @@ const logger = new Logger('RefreshService');
  * ```
  */
 export class RefreshService {
-    constructor(messageService, discussionService, announcementService, session, eventEmitter, queries) {
+    constructor(messageService, discussionService, announcementService, session, eventEmitter, queries, config) {
         Object.defineProperty(this, "messageService", {
             enumerable: true,
             configurable: true,
@@ -72,12 +72,46 @@ export class RefreshService {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sessionStatusMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         this.messageService = messageService;
         this.discussionService = discussionService;
         this.announcementService = announcementService;
         this.session = session;
         this.eventEmitter = eventEmitter;
         this.queries = queries;
+        this.config = config;
+    }
+    /**
+     * Emit sessionStatusChanged events for discussions whose session status
+     * has changed since the last check.
+     */
+    async refreshSessionsStatusEvent() {
+        const ownerUserId = this.session.userIdEncoded;
+        if (!ownerUserId) {
+            return;
+        }
+        const allRows = await this.queries.discussions.getByOwner(ownerUserId);
+        const discussions = toSortedDiscussions(allRows);
+        for (const discussion of discussions) {
+            const peerId = decodeUserId(discussion.contactUserId);
+            const status = this.session.peerSessionStatus(peerId);
+            const previous = this.sessionStatusMap.get(discussion.contactUserId);
+            if (previous !== status) {
+                this.sessionStatusMap.set(discussion.contactUserId, status);
+                this.eventEmitter.emit(SdkEventType.SESSION_STATUS_CHANGED, discussion.contactUserId, status);
+            }
+        }
     }
     /**
      * Update state for all discussions:
@@ -128,39 +162,27 @@ export class RefreshService {
             for (const discussion of discussions) {
                 const peerId = decodeUserId(discussion.contactUserId);
                 const status = this.session.peerSessionStatus(peerId);
-                if ([
-                    SessionStatus.Killed,
-                    SessionStatus.Saturated,
-                    SessionStatus.NoSession,
-                    SessionStatus.UnknownPeer,
-                ].includes(status)) {
-                    if (discussion.weAccepted) {
-                        const res = await this.discussionService.createSessionForContact(discussion.contactUserId, new Uint8Array(0));
-                        if (!res.success) {
-                            log.error('failed to create session for contact', {
-                                contactUserId: discussion.contactUserId,
-                                error: res.error,
-                            });
-                        }
-                        else {
-                            this.eventEmitter.emit(SdkEventType.SESSION_RENEWED, discussion);
-                        }
-                    }
-                }
+                await this.handleSessionStatus(discussion, status);
             }
             // Step 2: send announcements
             const refreshRows = await this.queries.discussions.getByOwner(ownerUserId);
             const discussionsAfterRefresh = toSortedDiscussions(refreshRows);
             const activePendingDiscussions = discussionsAfterRefresh.filter(discussion => {
                 const status = this.session.peerSessionStatus(decodeUserId(discussion.contactUserId));
-                return [SessionStatus.Active, SessionStatus.SelfRequested].includes(status);
+                return [
+                    SessionStatus.Active,
+                    SessionStatus.SelfRequested,
+                    SessionStatus.Saturated,
+                ].includes(status);
             });
             await this.announcementService.processOutgoingAnnouncements(activePendingDiscussions);
             // Step 3: send queued messages and keep-alives
-            // NOTE: only flush queued messages once the session is fully Active.
+            // NOTE: only flush queued messages once the session is fully Active or saturated.
             // SelfRequested means the handshake is still establishing and
             // session.sendMessage() can return null.
-            const activeEstablishedDiscussions = activePendingDiscussions.filter(discussion => this.session.peerSessionStatus(decodeUserId(discussion.contactUserId)) === SessionStatus.Active);
+            const activeEstablishedDiscussions = activePendingDiscussions.filter(discussion => 
+            // saturated sessions can't send messages on session manager but it's still possible to send on network msg that have already been encrypted if any
+            [SessionStatus.Active, SessionStatus.Saturated].includes(this.session.peerSessionStatus(decodeUserId(discussion.contactUserId))));
             const keepAliveSet = new Set(keepAlivePeerIds);
             for (const discussion of activeEstablishedDiscussions) {
                 if (!discussion.weAccepted)
@@ -202,4 +224,126 @@ export class RefreshService {
             this.isUpdating = false;
         }
     }
+    getJitteredDelayMs(baseMs, jitterMs) {
+        const jitter = (Math.random() * 2 - 1) * jitterMs;
+        return Math.max(0, Math.round(baseMs + jitter));
+    }
+    async updateSessionRecovery(discussion, updates) {
+        if (!discussion.id) {
+            return;
+        }
+        if (!updates) {
+            // Clear all recovery fields
+            if ((discussion.killedNextRetryAt === null ||
+                discussion.killedNextRetryAt === undefined) &&
+                (discussion.saturatedRetryAt === null ||
+                    discussion.saturatedRetryAt === undefined) &&
+                (discussion.saturatedRetryDone === null ||
+                    discussion.saturatedRetryDone === undefined)) {
+                return; // Already cleared
+            }
+            const updateData = {
+                killedNextRetryAt: null,
+                saturatedRetryAt: null,
+                saturatedRetryDone: false,
+            };
+            await this.queries.discussions.updateById(discussion.id, updateData);
+            return;
+        }
+        const currentNormalized = {
+            killedNextRetryAt: discussion.killedNextRetryAt?.getTime() ?? null,
+            saturatedRetryAt: discussion.saturatedRetryAt?.getTime() ?? null,
+        };
+        const nextNormalized = {
+            killedNextRetryAt: updates.killedNextRetryAt?.getTime() ?? null,
+            saturatedRetryAt: updates.saturatedRetryAt?.getTime() ?? null,
+        };
+        const isSame = currentNormalized.killedNextRetryAt ===
+            nextNormalized.killedNextRetryAt &&
+            currentNormalized.saturatedRetryAt === nextNormalized.saturatedRetryAt &&
+            discussion.saturatedRetryDone === updates.saturatedRetryDone;
+        if (isSame) {
+            return;
+        }
+        const updateData = {
+            killedNextRetryAt: updates.killedNextRetryAt,
+            saturatedRetryAt: updates.saturatedRetryAt,
+            saturatedRetryDone: updates.saturatedRetryDone,
+        };
+        await this.queries.discussions.updateById(discussion.id, updateData);
+    }
+    async handleSessionStatus(discussion, status) {
+        const now = new Date();
+        const log = logger.forMethod('handleSessionStatus');
+        if (status === SessionStatus.Active) {
+            await this.updateSessionRecovery(discussion, undefined);
+            return;
+        }
+        if ([SessionStatus.SelfRequested, SessionStatus.PeerRequested].includes(status)) {
+            return;
+        }
+        if (!discussion.weAccepted) {
+            return;
+        }
+        if (status === SessionStatus.NoSession ||
+            status === SessionStatus.UnknownPeer) {
+            log.error('no session or unknown peer', {
+                contactUserId: discussion.contactUserId,
+                status: status,
+            });
+            return;
+        }
+        if (status === SessionStatus.Killed) {
+            const nextRetryAt = discussion.killedNextRetryAt;
+            if (nextRetryAt && nextRetryAt.getTime() > now.getTime()) {
+                return;
+            }
+            const res = await this.discussionService.createSessionForContact(discussion.contactUserId, new Uint8Array(0));
+            if (!res.success) {
+                log.error('failed to create session for contact', {
+                    contactUserId: discussion.contactUserId,
+                    error: res.error,
+                });
+                return; // if we failed to create session, we don't want to set killedNextRetryAt
+            }
+            else {
+                this.eventEmitter.emit(SdkEventType.SESSION_RENEWED, discussion);
+            }
+            const delayMs = this.getJitteredDelayMs(this.config.sessionRecovery.killedRetryDelayMs, this.config.sessionRecovery.JitterMs);
+            await this.updateSessionRecovery(discussion, {
+                killedNextRetryAt: new Date(now.getTime() + delayMs),
+                saturatedRetryDone: false,
+            });
+            return;
+        }
+        if (status === SessionStatus.Saturated) {
+            const retryAt = discussion.saturatedRetryAt;
+            if (discussion.saturatedRetryDone ||
+                (retryAt && retryAt.getTime() > now.getTime())) {
+                return;
+            }
+            if (!retryAt) {
+                const delayMs = this.getJitteredDelayMs(this.config.sessionRecovery.saturatedRetryDelayMs, this.config.sessionRecovery.JitterMs);
+                await this.updateSessionRecovery(discussion, {
+                    saturatedRetryAt: new Date(now.getTime() + delayMs),
+                    saturatedRetryDone: false,
+                });
+                return;
+            }
+            const res = await this.discussionService.createSessionForContact(discussion.contactUserId, new Uint8Array(0));
+            if (!res.success) {
+                log.error('failed to create session for contact', {
+                    contactUserId: discussion.contactUserId,
+                    error: res.error,
+                });
+                return; // if we failed to create session, we don't want to set saturatedRetryDone to true
+            }
+            else {
+                this.eventEmitter.emit(SdkEventType.SESSION_RENEWED, discussion);
+            }
+            await this.updateSessionRecovery(discussion, {
+                saturatedRetryDone: true,
+            });
+        }
+    }
 }

package/dist/wasm/index.d.ts

@@ -8,4 +8,4 @@ export { SessionModule, sessionStatusToString } from './session.js';
 export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from './loader.js';
 export * from './encryption.js';
 export * from './userKeys.js';
-export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings.js';
+export { SessionStatus, SessionConfig, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings.js';

package/dist/wasm/index.js

@@ -10,4 +10,4 @@ export { SessionModule, sessionStatusToString } from './session.js';
 export { initializeWasm, ensureWasmInitialized, startWasmInitialization, } from './loader.js';
 export * from './encryption.js';
 export * from './userKeys.js';
-export { SessionStatus, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings.js';
+export { SessionStatus, SessionConfig, UserPublicKeys, UserSecretKeys, SendMessageOutput, ReceiveMessageOutput, AnnouncementResult, } from './bindings.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massalabs/gossip-sdk",
-  "version": "0.0.2-dev.20260226131013",
+  "version": "0.0.2-dev.20260302112618",
   "description": "Gossip SDK for automation, chatbot, and integration use cases",
   "type": "module",
   "main": "./dist/index.js",