@agntcy/slim-bindings-linux-arm64-gnu 2.0.0-alpha.4 → 2.0.0-alpha.7

package/slim_bindings.js

@@ -15,7 +15,7 @@ typeof process !== "object" ||
     false;
 // Public interface members begin here.
 /**
- * Create a new Service with builder pattern
+ * Create a new Service with builder pattern (native only)
  */
 export function createService(name) {
     return FfiConverterTypeService.lift(uniffiCaller.rustCallWithError(
@@ -26,7 +26,7 @@ export function createService(name) {
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
 /**
- * Create a new Service with configuration
+ * Create a new Service with configuration (native only)
  */
 export function createServiceWithConfig(name, config) {
     return FfiConverterTypeService.lift(uniffiCaller.rustCallWithError(
@@ -229,7 +229,7 @@ export function newConfigFromJson(json) {
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
 /**
- * Create a new DataplaneConfig
+ * Create a new DataplaneConfig (native only)
  */
 export function newDataplaneConfig() {
     return ((__rb) => {
@@ -384,7 +384,7 @@ export function newServiceConfig() {
 /**
  * Create a new BindingsServiceConfig with custom values
  */
-export function newServiceConfigWith(nodeId, groupName, dataplane) {
+export function newServiceConfigWith(nodeId, domainName, dataplane) {
     return ((__rb) => {
         try {
             return FfiConverterTypeServiceConfig.lift(__rb);
@@ -394,12 +394,12 @@ export function newServiceConfigWith(nodeId, groupName, dataplane) {
         }
     })(uniffiCaller.rustCall(
     /*caller:*/ (callStatus) => {
-        return nativeModule().uniffi_slim_bindings_fn_func_new_service_config_with(FfiConverterOptionalString.lower(nodeId, nativeModule().rustbuffer_alloc), FfiConverterOptionalString.lower(groupName, nativeModule().rustbuffer_alloc), FfiConverterTypeDataplaneConfig.lower(dataplane, nativeModule().rustbuffer_alloc), callStatus);
+        return nativeModule().uniffi_slim_bindings_fn_func_new_service_config_with(FfiConverterOptionalString.lower(nodeId, nativeModule().rustbuffer_alloc), FfiConverterOptionalString.lower(domainName, nativeModule().rustbuffer_alloc), FfiConverterTypeDataplaneConfig.lower(dataplane, nativeModule().rustbuffer_alloc), callStatus);
     }, 
     /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
 }
 /**
- * Create a new ServiceConfiguration
+ * Create a new ServiceConfiguration (native only)
  */
 export function newServiceConfiguration() {
     return ((__rb) => {
@@ -2724,14 +2724,115 @@ const FfiConverterTypeMlsSettings = (() => {
     class FFIConverter extends AbstractFfiConverterByteArray {
         read(from) {
             return {
-                headerIntegrityValidationPercent: FfiConverterUInt32.read(from)
+                headerIntegrityValidationPercent: FfiConverterUInt32.read(from),
+                maxSeenControlMessageIdsSize: FfiConverterOptionalUInt64.read(from)
             };
         }
         write(value, into) {
             FfiConverterUInt32.write(value.headerIntegrityValidationPercent, into);
+            FfiConverterOptionalUInt64.write(value.maxSeenControlMessageIdsSize, into);
         }
         allocationSize(value) {
-            return FfiConverterUInt32.allocationSize(value.headerIntegrityValidationPercent);
+            return FfiConverterUInt32.allocationSize(value.headerIntegrityValidationPercent) +
+                FfiConverterOptionalUInt64.allocationSize(value.maxSeenControlMessageIdsSize);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Online/offline status of a session participant
+ */
+export var ParticipantStatus;
+(function (ParticipantStatus) {
+    ParticipantStatus[ParticipantStatus["Online"] = 0] = "Online";
+    ParticipantStatus[ParticipantStatus["Offline"] = 1] = "Offline";
+})(ParticipantStatus || (ParticipantStatus = {}));
+const FfiConverterTypeParticipantStatus = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return ParticipantStatus.Online;
+                case 2: return ParticipantStatus.Offline;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case ParticipantStatus.Online: return ordinalConverter.write(1, into);
+                case ParticipantStatus.Offline: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link ParticipantInfo} record objects.
+ */
+export const ParticipantInfo = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypeParticipantInfo = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                name: FfiConverterTypeName.read(from),
+                status: FfiConverterTypeParticipantStatus.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterTypeName.write(value.name, into);
+            FfiConverterTypeParticipantStatus.write(value.status, into);
+        }
+        allocationSize(value) {
+            return FfiConverterTypeName.allocationSize(value.name) +
+                FfiConverterTypeParticipantStatus.allocationSize(value.status);
+        }
+    }
+    ;
+    return new FFIConverter();
+})();
+/**
+ * Generated factory for {@link PersistenceConfig} record objects.
+ */
+export const PersistenceConfig = (() => {
+    const defaults = () => ({});
+    const create = (() => {
+        return uniffiCreateRecord(defaults);
+    })();
+    return Object.freeze({
+        create,
+        new: create,
+        defaults: () => Object.freeze(defaults()),
+    });
+})();
+const FfiConverterTypePersistenceConfig = (() => {
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            return {
+                path: FfiConverterString.read(from),
+                passphrase: FfiConverterOptionalString.read(from)
+            };
+        }
+        write(value, into) {
+            FfiConverterString.write(value.path, into);
+            FfiConverterOptionalString.write(value.passphrase, into);
+        }
+        allocationSize(value) {
+            return FfiConverterString.allocationSize(value.path) +
+                FfiConverterOptionalString.allocationSize(value.passphrase);
         }
     }
     ;
@@ -2827,18 +2928,18 @@ const FfiConverterTypeServiceConfig = (() => {
         read(from) {
             return {
                 nodeId: FfiConverterOptionalString.read(from),
-                groupName: FfiConverterOptionalString.read(from),
+                domainName: FfiConverterOptionalString.read(from),
                 dataplane: FfiConverterTypeDataplaneConfig.read(from)
             };
         }
         write(value, into) {
             FfiConverterOptionalString.write(value.nodeId, into);
-            FfiConverterOptionalString.write(value.groupName, into);
+            FfiConverterOptionalString.write(value.domainName, into);
             FfiConverterTypeDataplaneConfig.write(value.dataplane, into);
         }
         allocationSize(value) {
             return FfiConverterOptionalString.allocationSize(value.nodeId) +
-                FfiConverterOptionalString.allocationSize(value.groupName) +
+                FfiConverterOptionalString.allocationSize(value.domainName) +
                 FfiConverterTypeDataplaneConfig.allocationSize(value.dataplane);
         }
     }
@@ -3562,6 +3663,45 @@ const uniffiTypeCompletionHandleObjectFactory = (() => {
     };
 })();
 const FfiConverterTypeCompletionHandle = new FfiConverterObject(uniffiTypeCompletionHandleObjectFactory);
+/**
+ * How a session should be closed.
+ */
+export var CloseMode;
+(function (CloseMode) {
+    /**
+     * Soft close: go offline so the session can be brought back later with
+     * `rejoin()`. This is an in-memory group operation and does not require
+     * persistence (though a persisted session also survives a process restart).
+     * Not valid for point-to-point sessions.
+     */
+    CloseMode[CloseMode["Soft"] = 0] = "Soft";
+    /**
+     * Hard close: terminate the session permanently.
+     */
+    CloseMode[CloseMode["Hard"] = 1] = "Hard";
+})(CloseMode || (CloseMode = {}));
+const FfiConverterTypeCloseMode = (() => {
+    const ordinalConverter = FfiConverterInt32;
+    class FFIConverter extends AbstractFfiConverterByteArray {
+        read(from) {
+            switch (ordinalConverter.read(from)) {
+                case 1: return CloseMode.Soft;
+                case 2: return CloseMode.Hard;
+                default: throw new UniffiInternalError.UnexpectedEnumCase();
+            }
+        }
+        write(value, into) {
+            switch (value) {
+                case CloseMode.Soft: return ordinalConverter.write(1, into);
+                case CloseMode.Hard: return ordinalConverter.write(2, into);
+            }
+        }
+        allocationSize(value) {
+            return ordinalConverter.allocationSize(0);
+        }
+    }
+    return new FFIConverter();
+})();
 /**
  * Session context for language bindings (UniFFI-compatible)
  *
@@ -3576,6 +3716,176 @@ export class Session extends UniffiAbstractObject {
         this[pointerLiteralSymbol] = pointer;
         this[destructorGuardSymbol] = uniffiTypeSessionObjectFactory.bless(pointer);
     }
+    /**
+     * Hard-close the session (blocking version): terminate it permanently.
+     * For a soft, restorable close use [`Self::close_with_mode`].
+     */
+    close() {
+        return FfiConverterTypeCompletionHandle.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_bindings_fn_method_session_close(uniffiTypeSessionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Hard-close the session and wait for completion (blocking version). See [`Self::close`].
+     */
+    closeAndWait() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_bindings_fn_method_session_close_and_wait(uniffiTypeSessionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Hard-close the session and wait for completion (async version). See [`Self::close`].
+     */
+    async closeAndWaitAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_close_and_wait_async(uniffiTypeSessionObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Hard-close the session (async version). See [`Self::close`].
+     */
+    async closeAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_close_async(uniffiTypeSessionObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeCompletionHandle.lift.bind(FfiConverterTypeCompletionHandle), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Close the session with an explicit [`CloseMode`] (blocking version).
+     *
+     * [`CloseMode::Soft`] notifies the group that this participant is going
+     * offline so it can be brought back with `rejoin()` (an in-memory group
+     * operation; persistence is not required). Only valid for Group sessions;
+     * returns an error for PointToPoint sessions. [`CloseMode::Hard`] terminates
+     * the session permanently. Returns a completion handle that resolves when
+     * ACKs are collected or on timeout.
+     */
+    closeWithMode(mode) {
+        return FfiConverterTypeCompletionHandle.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_bindings_fn_method_session_close_with_mode(uniffiTypeSessionObjectFactory.clonePointer(this), FfiConverterTypeCloseMode.lower(mode, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (blocking version).
+     */
+    closeWithModeAndWait(mode) {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_bindings_fn_method_session_close_with_mode_and_wait(uniffiTypeSessionObjectFactory.clonePointer(this), FfiConverterTypeCloseMode.lower(mode, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Close the session with an explicit [`CloseMode`] and wait for completion (async version).
+     */
+    async closeWithModeAndWaitAsync(mode, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_close_with_mode_and_wait_async(uniffiTypeSessionObjectFactory.clonePointer(this), FfiConverterTypeCloseMode.lower(mode, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Close the session with an explicit [`CloseMode`] (async version). See [`Self::close_with_mode`].
+     */
+    async closeWithModeAsync(mode, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_close_with_mode_async(uniffiTypeSessionObjectFactory.clonePointer(this), FfiConverterTypeCloseMode.lower(mode, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeCompletionHandle.lift.bind(FfiConverterTypeCompletionHandle), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
     /**
      * Get the session configuration
      */
@@ -3781,12 +4091,12 @@ export class Session extends UniffiAbstractObject {
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
     /**
-     * Get list of participants in the session (blocking version for FFI)
+     * Get list of participants in the session with their online/offline status (blocking version for FFI)
      */
     participantsList() {
         return ((__rb) => {
             try {
-                return FfiConverterSequenceTypeName.lift(__rb);
+                return FfiConverterSequenceTypeParticipantInfo.lift(__rb);
             }
             finally {
                 nativeModule().rustbuffer_free(__rb);
@@ -3799,7 +4109,7 @@ export class Session extends UniffiAbstractObject {
         /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
     }
     /**
-     * Get list of participants in the session
+     * Get list of participants in the session with their online/offline status (async version)
      */
     async participantsListAsync(asyncOpts_) {
         const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -3818,7 +4128,7 @@ export class Session extends UniffiAbstractObject {
             // RustBuffer comes back via the shared `rust_future_complete_*`
             // export. The bytes the runtime hands back must be deserialized
             // here using the per-callable return-type converter.
-            /*liftFunc:*/ FfiConverterSequenceTypeName.lift.bind(FfiConverterSequenceTypeName), 
+            /*liftFunc:*/ FfiConverterSequenceTypeParticipantInfo.lift.bind(FfiConverterSequenceTypeParticipantInfo), 
             /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
             /*asyncOpts:*/ asyncOpts_, 
             /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
@@ -4086,6 +4396,91 @@ export class Session extends UniffiAbstractObject {
             throw __error;
         }
     }
+    /**
+     * Notify the group that this participant is back online (blocking version).
+     *
+     * Only valid for Group sessions; returns an error for PointToPoint sessions.
+     * Returns a completion handle that resolves when ACKs/NACKs are collected.
+     * If any participant NACKs due to an MLS epoch mismatch, the rejoin fails.
+     */
+    rejoin() {
+        return FfiConverterTypeCompletionHandle.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_bindings_fn_method_session_rejoin(uniffiTypeSessionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Notify the group that this participant is back online and wait for completion (blocking version).
+     */
+    rejoinAndWait() {
+        uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            nativeModule().uniffi_slim_bindings_fn_method_session_rejoin_and_wait(uniffiTypeSessionObjectFactory.clonePointer(this), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString));
+    }
+    /**
+     * Notify the group that this participant is back online and wait for completion (async version).
+     */
+    async rejoinAndWaitAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_rejoin_and_wait_async(uniffiTypeSessionObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_void, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_void, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_void, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_void, 
+            /*liftFunc:*/ (_v) => { }, 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
+    /**
+     * Notify the group that this participant is back online (async version).
+     */
+    async rejoinAsync(asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_session_rejoin_async(uniffiTypeSessionObjectFactory.clonePointer(this));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeCompletionHandle.lift.bind(FfiConverterTypeCompletionHandle), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
     /**
      * Remove a participant from the session (blocking version)
      *
@@ -4827,12 +5222,16 @@ const FfiConverterTypeTransportProtocol = (() => {
     return new FFIConverter();
 })();
 /**
- * Adapter that bridges the App API with language-bindings interface
+ * Adapter that bridges the App API with the language-bindings interface.
+ *
+ * Both native and browser builds wrap the same [`slim_service::app::App`] with
+ * the same `AuthProvider`/`AuthVerifier` type parameters; the only structural
+ * difference is the lifecycle owner:
  *
- * This adapter uses enum-based auth types (`AuthProvider`/`AuthVerifier`) instead of generics
- * to be compatible with UniFFI, supporting multiple authentication mechanisms (SharedSecret,
- * JWT, SPIRE, StaticToken). It provides both synchronous (blocking) and asynchronous methods
- * for flexibility.
+ * - Native keeps the owning [`slim_service::Service`] alive.
+ * - Browser (wasm32) uses `AuthProvider::SharedSecret` identity and keeps the
+ * WebSocket [`slim_datapath::message_processing::MessageProcessor`] alive
+ * together with the upstream connection id.
  */
 export class App extends UniffiAbstractObject {
     /**
@@ -5215,6 +5614,63 @@ export class App extends UniffiAbstractObject {
             throw __error;
         }
     }
+    /**
+     * Blocking wrapper around [`App::restore_sessions_async`].
+     */
+    restoreSessions(connId) {
+        return ((__rb) => {
+            try {
+                return FfiConverterSequenceTypeSession.lift(__rb);
+            }
+            finally {
+                nativeModule().rustbuffer_free(__rb);
+            }
+        })(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_bindings_fn_method_app_restore_sessions(uniffiTypeAppObjectFactory.clonePointer(this), FfiConverterUInt64.lower(connId, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Restore the app's persisted sessions after a restart (async).
+     *
+     * Only meaningful for an app created with
+     * [`crate::service::Service::create_app_with_persistence`]; returns an
+     * empty list when persistence is disabled. `conn_id` must be the live
+     * upstream connection to the node (the one the app subscribes over).
+     * Each restored session rejoins its MLS group without repeating the
+     * invite/welcome handshake.
+     */
+    async restoreSessionsAsync(connId, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_app_restore_sessions_async(uniffiTypeAppObjectFactory.clonePointer(this), FfiConverterUInt64.lower(connId, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_rust_buffer, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_rust_buffer, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_rust_buffer, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_rust_buffer, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterSequenceTypeSession.lift.bind(FfiConverterSequenceTypeSession), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
     /**
      * Set a route to a name for a specific connection (blocking version for FFI)
      */
@@ -5620,6 +6076,54 @@ export class Service extends UniffiAbstractObject {
             throw __error;
         }
     }
+    /**
+     * Blocking wrapper around [`Service::create_app_with_persistence_async`].
+     */
+    createAppWithPersistence(name, identityProviderConfig, identityVerifierConfig, direction, persistence) {
+        return FfiConverterTypeApp.lift(uniffiCaller.rustCallWithError(
+        /*liftError:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError), 
+        /*caller:*/ (callStatus) => {
+            return nativeModule().uniffi_slim_bindings_fn_method_service_create_app_with_persistence(uniffiTypeServiceObjectFactory.clonePointer(this), FfiConverterTypeName.lower(name, nativeModule().rustbuffer_alloc), FfiConverterTypeIdentityProviderConfig.lower(identityProviderConfig, nativeModule().rustbuffer_alloc), FfiConverterTypeIdentityVerifierConfig.lower(identityVerifierConfig, nativeModule().rustbuffer_alloc), FfiConverterTypeDirection.lower(direction, nativeModule().rustbuffer_alloc), FfiConverterTypePersistenceConfig.lower(persistence, nativeModule().rustbuffer_alloc), callStatus);
+        }, 
+        /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString)));
+    }
+    /**
+     * Create an app with restorable MLS/session state persisted under
+     * `persistence.path` (async).
+     *
+     * Mirror of [`Service::create_app_with_direction_async`] with persistence
+     * enabled. Restore the app's sessions after a restart with
+     * [`App::restore_sessions`].
+     */
+    async createAppWithPersistenceAsync(name, identityProviderConfig, identityVerifierConfig, direction, persistence, asyncOpts_) {
+        const __stack = uniffiIsDebug ? new Error().stack : undefined;
+        try {
+            return await uniffiRustCallAsync(
+            /*rustCaller:*/ uniffiCaller, 
+            /*rustFutureFunc:*/ () => {
+                return nativeModule().uniffi_slim_bindings_fn_method_service_create_app_with_persistence_async(uniffiTypeServiceObjectFactory.clonePointer(this), FfiConverterTypeName.lower(name, nativeModule().rustbuffer_alloc), FfiConverterTypeIdentityProviderConfig.lower(identityProviderConfig, nativeModule().rustbuffer_alloc), FfiConverterTypeIdentityVerifierConfig.lower(identityVerifierConfig, nativeModule().rustbuffer_alloc), FfiConverterTypeDirection.lower(direction, nativeModule().rustbuffer_alloc), FfiConverterTypePersistenceConfig.lower(persistence, nativeModule().rustbuffer_alloc));
+            }, 
+            /*pollFunc:*/ nativeModule().ffi_slim_bindings_rust_future_poll_u64, 
+            /*cancelFunc:*/ nativeModule().ffi_slim_bindings_rust_future_cancel_u64, 
+            /*completeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_complete_u64, 
+            /*freeFunc:*/ nativeModule().ffi_slim_bindings_rust_future_free_u64, 
+            // Async returns always go through the JS-side converter: the
+            // FFI symbol returns the future handle (u64), and the user-level
+            // RustBuffer comes back via the shared `rust_future_complete_*`
+            // export. The bytes the runtime hands back must be deserialized
+            // here using the per-callable return-type converter.
+            /*liftFunc:*/ FfiConverterTypeApp.lift.bind(FfiConverterTypeApp), 
+            /*liftString:*/ FfiConverterString.lift.bind(FfiConverterString), 
+            /*asyncOpts:*/ asyncOpts_, 
+            /*errorHandler:*/ FfiConverterTypeSlimError.lift.bind(FfiConverterTypeSlimError));
+        }
+        catch (__error) {
+            if (uniffiIsDebug && __error instanceof Error) {
+                __error.stack = __stack;
+            }
+            throw __error;
+        }
+    }
     /**
      * Create a new App with SharedSecret authentication (helper function)
      *
@@ -5960,8 +6464,10 @@ const FfiConverterSequenceTypeClientConfig = new FfiConverterArray(FfiConverterT
 const FfiConverterOptionalTypeName = new FfiConverterOptional(FfiConverterTypeName);
 // FfiConverter for MlsSettings | undefined
 const FfiConverterOptionalTypeMlsSettings = new FfiConverterOptional(FfiConverterTypeMlsSettings);
-// FfiConverter for Array<NameLike>
-const FfiConverterSequenceTypeName = new FfiConverterArray(FfiConverterTypeName);
+// FfiConverter for Array<ParticipantInfo>
+const FfiConverterSequenceTypeParticipantInfo = new FfiConverterArray(FfiConverterTypeParticipantInfo);
+// FfiConverter for Array<SessionLike>
+const FfiConverterSequenceTypeSession = new FfiConverterArray(FfiConverterTypeSession);
 // FfiConverter for Array<ServiceLike>
 const FfiConverterSequenceTypeService = new FfiConverterArray(FfiConverterTypeService);
 // FfiConverter for Array<ServiceConfig>
@@ -5984,10 +6490,10 @@ function uniffiEnsureInitialized() {
     if (bindingsContractVersion !== scaffoldingContractVersion) {
         throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_func_create_service() !== 40378) {
+    if (nativeModule().uniffi_slim_bindings_checksum_func_create_service() !== 12289) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_create_service");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_func_create_service_with_config() !== 45305) {
+    if (nativeModule().uniffi_slim_bindings_checksum_func_create_service_with_config() !== 64956) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_create_service_with_config");
     }
     if (nativeModule().uniffi_slim_bindings_checksum_func_get_build_info() !== 42926) {
@@ -6020,7 +6526,7 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_func_new_config_from_json() !== 6580) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_new_config_from_json");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_func_new_dataplane_config() !== 39512) {
+    if (nativeModule().uniffi_slim_bindings_checksum_func_new_dataplane_config() !== 15621) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_new_dataplane_config");
     }
     if (nativeModule().uniffi_slim_bindings_checksum_func_new_insecure_client_config() !== 1116) {
@@ -6047,10 +6553,10 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_func_new_service_config() !== 53554) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_new_service_config");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_func_new_service_config_with() !== 7110) {
+    if (nativeModule().uniffi_slim_bindings_checksum_func_new_service_config_with() !== 1207) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_new_service_config_with");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_func_new_service_configuration() !== 47743) {
+    if (nativeModule().uniffi_slim_bindings_checksum_func_new_service_configuration() !== 33994) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_func_new_service_configuration");
     }
     if (nativeModule().uniffi_slim_bindings_checksum_func_new_tracing_config() !== 4571) {
@@ -6113,6 +6619,12 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_method_app_remove_route_async() !== 31663) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_app_remove_route_async");
     }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_app_restore_sessions() !== 35786) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_app_restore_sessions");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_app_restore_sessions_async() !== 48735) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_app_restore_sessions_async");
+    }
     if (nativeModule().uniffi_slim_bindings_checksum_method_app_set_route() !== 35913) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_app_set_route");
     }
@@ -6185,6 +6697,12 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_method_service_create_app_with_direction_async() !== 54968) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_service_create_app_with_direction_async");
     }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_service_create_app_with_persistence() !== 56347) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_service_create_app_with_persistence");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_service_create_app_with_persistence_async() !== 7716) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_service_create_app_with_persistence_async");
+    }
     if (nativeModule().uniffi_slim_bindings_checksum_method_service_create_app_with_secret() !== 28202) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_service_create_app_with_secret");
     }
@@ -6221,6 +6739,30 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_method_service_stop_server() !== 50154) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_service_stop_server");
     }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close() !== 13985) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_and_wait() !== 17849) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_and_wait");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_and_wait_async() !== 26578) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_and_wait_async");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_async() !== 28685) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_async");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_with_mode() !== 39709) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_with_mode");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_with_mode_and_wait() !== 21397) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_with_mode_and_wait");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_with_mode_and_wait_async() !== 56735) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_with_mode_and_wait_async");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_close_with_mode_async() !== 33958) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_close_with_mode_async");
+    }
     if (nativeModule().uniffi_slim_bindings_checksum_method_session_config() !== 40937) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_config");
     }
@@ -6251,10 +6793,10 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_method_session_metadata() !== 34109) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_metadata");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_method_session_participants_list() !== 46055) {
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_participants_list() !== 20398) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_participants_list");
     }
-    if (nativeModule().uniffi_slim_bindings_checksum_method_session_participants_list_async() !== 56340) {
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_participants_list_async() !== 11035) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_participants_list_async");
     }
     if (nativeModule().uniffi_slim_bindings_checksum_method_session_publish() !== 14079) {
@@ -6287,6 +6829,18 @@ function uniffiEnsureInitialized() {
     if (nativeModule().uniffi_slim_bindings_checksum_method_session_publish_with_params_async() !== 5640) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_publish_with_params_async");
     }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_rejoin() !== 5034) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_rejoin");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_rejoin_and_wait() !== 26363) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_rejoin_and_wait");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_rejoin_and_wait_async() !== 40985) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_rejoin_and_wait_async");
+    }
+    if (nativeModule().uniffi_slim_bindings_checksum_method_session_rejoin_async() !== 49489) {
+        throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_rejoin_async");
+    }
     if (nativeModule().uniffi_slim_bindings_checksum_method_session_remove() !== 276) {
         throw new UniffiInternalError.ApiChecksumMismatch("uniffi_slim_bindings_checksum_method_session_remove");
     }
@@ -6320,6 +6874,7 @@ export default Object.freeze({
         FfiConverterTypeClientAuthenticationConfig,
         FfiConverterTypeClientConfig,
         FfiConverterTypeClientJwtAuth,
+        FfiConverterTypeCloseMode,
         FfiConverterTypeCompletionHandle,
         FfiConverterTypeCompressionType,
         FfiConverterTypeDataplaneConfig,
@@ -6339,6 +6894,9 @@ export default Object.freeze({
         FfiConverterTypeMessageContext,
         FfiConverterTypeMlsSettings,
         FfiConverterTypeName,
+        FfiConverterTypeParticipantInfo,
+        FfiConverterTypeParticipantStatus,
+        FfiConverterTypePersistenceConfig,
         FfiConverterTypeProxyConfig,
         FfiConverterTypeReceivedMessage,
         FfiConverterTypeRuntimeConfig,