@minip2p/react-native 0.4.6 → 0.4.8

package/lib/module/generated/minip2p_ffi.js

@@ -6,7 +6,7 @@
 /* eslint-disable */
 // @ts-nocheck
 import nativeModule from "./minip2p_ffi-ffi.js";
-import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterInt32, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTraitInterfaceCall, uniffiTypeNameSymbol } from "@ubjs/core";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterArrayBuffer, FfiConverterBool, FfiConverterObject, FfiConverterObjectWithCallbacks, FfiConverterOptional, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiEnum, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTraitInterfaceCall, uniffiTypeNameSymbol } from "@ubjs/core";
 const uniffiCaller = new UniffiRustCaller(() => ({
   code: 0
 }));
@@ -20,49 +20,44 @@ process?.env?.NODE_ENV !== "production" || false;
 
 /**
  * Builds a circuit multiaddress for `peer_id` through `relay_addr`.
- *
- * `relay_addr` is any direct `/quic-v1` or `/tcp` peer address.
  */
 export function circuitAddress(relayAddr, peerId) /*throws*/{
-  return (__rb => {
-    try {
-      return FfiConverterString.lift(__rb);
-    } finally {
-      nativeModule().rustbuffer_free(__rb);
-    }
-  })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+  const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
     return nativeModule().ubrn_uniffi_minip2p_ffi_fn_func_circuit_address(FfiConverterString.lower(relayAddr, nativeModule().rustbuffer_alloc), FfiConverterString.lower(peerId, nativeModule().rustbuffer_alloc), callStatus);
-  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterString.lift(__rb);
+  } finally {
+    nativeModule().rustbuffer_free(__rb);
+  }
 }
 
 /**
  * Generates raw Ed25519 secret key material.
  */
 export function generateSecretKey() {
-  return (__rb => {
-    try {
-      return FfiConverterArrayBuffer.lift(__rb);
-    } finally {
-      nativeModule().rustbuffer_free(__rb);
-    }
-  })(uniffiCaller.rustCall(/*caller:*/callStatus => {
+  const __rb = uniffiCaller.rustCall(/*caller:*/callStatus => {
     return nativeModule().ubrn_uniffi_minip2p_ffi_fn_func_generate_secret_key(callStatus);
-  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterArrayBuffer.lift(__rb);
+  } finally {
+    nativeModule().rustbuffer_free(__rb);
+  }
 }
 
 /**
  * Derives a base58 peer ID from raw Ed25519 secret key material.
  */
 export function peerIdFromSecretKey(secretKey) /*throws*/{
-  return (__rb => {
-    try {
-      return FfiConverterString.lift(__rb);
-    } finally {
-      nativeModule().rustbuffer_free(__rb);
-    }
-  })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+  const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
     return nativeModule().ubrn_uniffi_minip2p_ffi_fn_func_peer_id_from_secret_key(FfiConverterArrayBuffer.lower(secretKey, nativeModule().rustbuffer_alloc), callStatus);
-  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+  }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+  try {
+    return FfiConverterString.lift(__rb);
+  } finally {
+    nativeModule().rustbuffer_free(__rb);
+  }
 }
 
 // Hermes (React Native ≥ 0.74) ships TextEncoder and encodeInto, but not
@@ -123,19 +118,19 @@ export const DiscoveryOptions = (() => {
 })();
 const FfiConverterTypeDiscoveryOptions = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        topic: FfiConverterString.read(from),
-        beaconIntervalMs: FfiConverterUInt64.read(from),
-        peerTtlMs: FfiConverterUInt64.read(from),
-        autoDial: FfiConverterBool.read(from)
+        topic: FfiConverterString.readFromCursor(c),
+        beaconIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        peerTtlMs: FfiConverterUInt64.readFromCursor(c),
+        autoDial: FfiConverterBool.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterString.write(value.topic, into);
-      FfiConverterUInt64.write(value.beaconIntervalMs, into);
-      FfiConverterUInt64.write(value.peerTtlMs, into);
-      FfiConverterBool.write(value.autoDial, into);
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.topic, c);
+      FfiConverterUInt64.writeIntoCursor(value.beaconIntervalMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.peerTtlMs, c);
+      FfiConverterBool.writeIntoCursor(value.autoDial, c);
     }
     allocationSize(value) {
       return FfiConverterString.allocationSize(value.topic) + FfiConverterUInt64.allocationSize(value.beaconIntervalMs) + FfiConverterUInt64.allocationSize(value.peerTtlMs) + FfiConverterBool.allocationSize(value.autoDial);
@@ -165,13 +160,13 @@ export const TransportOptions = (() => {
 })();
 const FfiConverterTypeTransportOptions = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        listenAddrs: FfiConverterOptionalSequenceString.read(from)
+        listenAddrs: FfiConverterOptionalSequenceString.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterOptionalSequenceString.write(value.listenAddrs, into);
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalSequenceString.writeIntoCursor(value.listenAddrs, c);
     }
     allocationSize(value) {
       return FfiConverterOptionalSequenceString.allocationSize(value.listenAddrs);
@@ -196,10 +191,9 @@ export let PubsubRouter = /*#__PURE__*/function (PubsubRouter) {
   return PubsubRouter;
 }({});
 const FfiConverterTypePubsubRouter = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return PubsubRouter.Gossipsub;
         case 2:
@@ -208,16 +202,16 @@ const FfiConverterTypePubsubRouter = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case PubsubRouter.Gossipsub:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case PubsubRouter.Floodsub:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -243,27 +237,27 @@ export const MdnsOptions = (() => {
 })();
 const FfiConverterTypeMdnsOptions = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        enableIpv6: FfiConverterBool.read(from),
-        ttlMs: FfiConverterUInt64.read(from),
-        queryIntervalMs: FfiConverterUInt64.read(from),
-        maxPacketBytes: FfiConverterUInt32.read(from),
-        maxAnnouncedAddrs: FfiConverterUInt32.read(from),
-        interfaceRefreshMs: FfiConverterUInt64.read(from),
-        socketPollIntervalMs: FfiConverterUInt64.read(from),
-        autoDial: FfiConverterBool.read(from)
+        enableIpv6: FfiConverterBool.readFromCursor(c),
+        ttlMs: FfiConverterUInt64.readFromCursor(c),
+        queryIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        maxPacketBytes: FfiConverterUInt32.readFromCursor(c),
+        maxAnnouncedAddrs: FfiConverterUInt32.readFromCursor(c),
+        interfaceRefreshMs: FfiConverterUInt64.readFromCursor(c),
+        socketPollIntervalMs: FfiConverterUInt64.readFromCursor(c),
+        autoDial: FfiConverterBool.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterBool.write(value.enableIpv6, into);
-      FfiConverterUInt64.write(value.ttlMs, into);
-      FfiConverterUInt64.write(value.queryIntervalMs, into);
-      FfiConverterUInt32.write(value.maxPacketBytes, into);
-      FfiConverterUInt32.write(value.maxAnnouncedAddrs, into);
-      FfiConverterUInt64.write(value.interfaceRefreshMs, into);
-      FfiConverterUInt64.write(value.socketPollIntervalMs, into);
-      FfiConverterBool.write(value.autoDial, into);
+    writeIntoCursor(value, c) {
+      FfiConverterBool.writeIntoCursor(value.enableIpv6, c);
+      FfiConverterUInt64.writeIntoCursor(value.ttlMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.queryIntervalMs, c);
+      FfiConverterUInt32.writeIntoCursor(value.maxPacketBytes, c);
+      FfiConverterUInt32.writeIntoCursor(value.maxAnnouncedAddrs, c);
+      FfiConverterUInt64.writeIntoCursor(value.interfaceRefreshMs, c);
+      FfiConverterUInt64.writeIntoCursor(value.socketPollIntervalMs, c);
+      FfiConverterBool.writeIntoCursor(value.autoDial, c);
     }
     allocationSize(value) {
       return FfiConverterBool.allocationSize(value.enableIpv6) + FfiConverterUInt64.allocationSize(value.ttlMs) + FfiConverterUInt64.allocationSize(value.queryIntervalMs) + FfiConverterUInt32.allocationSize(value.maxPacketBytes) + FfiConverterUInt32.allocationSize(value.maxAnnouncedAddrs) + FfiConverterUInt64.allocationSize(value.interfaceRefreshMs) + FfiConverterUInt64.allocationSize(value.socketPollIntervalMs) + FfiConverterBool.allocationSize(value.autoDial);
@@ -293,33 +287,33 @@ export const EndpointConfig = (() => {
 })();
 const FfiConverterTypeEndpointConfig = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        agentVersion: FfiConverterOptionalString.read(from),
-        relays: FfiConverterSequenceString.read(from),
-        autonatServers: FfiConverterSequenceString.read(from),
-        quic: FfiConverterOptionalTypeTransportOptions.read(from),
-        tcp: FfiConverterOptionalTypeTransportOptions.read(from),
-        forceRelay: FfiConverterBool.read(from),
-        allowUnsigned: FfiConverterBool.read(from),
-        pubsubRouter: FfiConverterTypePubsubRouter.read(from),
-        protocols: FfiConverterSequenceString.read(from),
-        discovery: FfiConverterOptionalTypeDiscoveryOptions.read(from),
-        mdns: FfiConverterOptionalTypeMdnsOptions.read(from)
+        agentVersion: FfiConverterOptionalString.readFromCursor(c),
+        relays: FfiConverterSequenceString.readFromCursor(c),
+        autonatServers: FfiConverterSequenceString.readFromCursor(c),
+        quic: FfiConverterOptionalTypeTransportOptions.readFromCursor(c),
+        tcp: FfiConverterOptionalTypeTransportOptions.readFromCursor(c),
+        forceRelay: FfiConverterBool.readFromCursor(c),
+        allowUnsigned: FfiConverterBool.readFromCursor(c),
+        pubsubRouter: FfiConverterTypePubsubRouter.readFromCursor(c),
+        protocols: FfiConverterSequenceString.readFromCursor(c),
+        discovery: FfiConverterOptionalTypeDiscoveryOptions.readFromCursor(c),
+        mdns: FfiConverterOptionalTypeMdnsOptions.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterOptionalString.write(value.agentVersion, into);
-      FfiConverterSequenceString.write(value.relays, into);
-      FfiConverterSequenceString.write(value.autonatServers, into);
-      FfiConverterOptionalTypeTransportOptions.write(value.quic, into);
-      FfiConverterOptionalTypeTransportOptions.write(value.tcp, into);
-      FfiConverterBool.write(value.forceRelay, into);
-      FfiConverterBool.write(value.allowUnsigned, into);
-      FfiConverterTypePubsubRouter.write(value.pubsubRouter, into);
-      FfiConverterSequenceString.write(value.protocols, into);
-      FfiConverterOptionalTypeDiscoveryOptions.write(value.discovery, into);
-      FfiConverterOptionalTypeMdnsOptions.write(value.mdns, into);
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
+      FfiConverterSequenceString.writeIntoCursor(value.relays, c);
+      FfiConverterSequenceString.writeIntoCursor(value.autonatServers, c);
+      FfiConverterOptionalTypeTransportOptions.writeIntoCursor(value.quic, c);
+      FfiConverterOptionalTypeTransportOptions.writeIntoCursor(value.tcp, c);
+      FfiConverterBool.writeIntoCursor(value.forceRelay, c);
+      FfiConverterBool.writeIntoCursor(value.allowUnsigned, c);
+      FfiConverterTypePubsubRouter.writeIntoCursor(value.pubsubRouter, c);
+      FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+      FfiConverterOptionalTypeDiscoveryOptions.writeIntoCursor(value.discovery, c);
+      FfiConverterOptionalTypeMdnsOptions.writeIntoCursor(value.mdns, c);
     }
     allocationSize(value) {
       return FfiConverterOptionalString.allocationSize(value.agentVersion) + FfiConverterSequenceString.allocationSize(value.relays) + FfiConverterSequenceString.allocationSize(value.autonatServers) + FfiConverterOptionalTypeTransportOptions.allocationSize(value.quic) + FfiConverterOptionalTypeTransportOptions.allocationSize(value.tcp) + FfiConverterBool.allocationSize(value.forceRelay) + FfiConverterBool.allocationSize(value.allowUnsigned) + FfiConverterTypePubsubRouter.allocationSize(value.pubsubRouter) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalTypeDiscoveryOptions.allocationSize(value.discovery) + FfiConverterOptionalTypeMdnsOptions.allocationSize(value.mdns);
@@ -349,23 +343,23 @@ export const IdentifyInfo = (() => {
 })();
 const FfiConverterTypeIdentifyInfo = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        publicKey: FfiConverterOptionalBytes.read(from),
-        listenAddrs: FfiConverterSequenceString.read(from),
-        protocols: FfiConverterSequenceString.read(from),
-        observedAddr: FfiConverterOptionalString.read(from),
-        protocolVersion: FfiConverterOptionalString.read(from),
-        agentVersion: FfiConverterOptionalString.read(from)
+        publicKey: FfiConverterOptionalBytes.readFromCursor(c),
+        listenAddrs: FfiConverterSequenceString.readFromCursor(c),
+        protocols: FfiConverterSequenceString.readFromCursor(c),
+        observedAddr: FfiConverterOptionalString.readFromCursor(c),
+        protocolVersion: FfiConverterOptionalString.readFromCursor(c),
+        agentVersion: FfiConverterOptionalString.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterOptionalBytes.write(value.publicKey, into);
-      FfiConverterSequenceString.write(value.listenAddrs, into);
-      FfiConverterSequenceString.write(value.protocols, into);
-      FfiConverterOptionalString.write(value.observedAddr, into);
-      FfiConverterOptionalString.write(value.protocolVersion, into);
-      FfiConverterOptionalString.write(value.agentVersion, into);
+    writeIntoCursor(value, c) {
+      FfiConverterOptionalBytes.writeIntoCursor(value.publicKey, c);
+      FfiConverterSequenceString.writeIntoCursor(value.listenAddrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.protocols, c);
+      FfiConverterOptionalString.writeIntoCursor(value.observedAddr, c);
+      FfiConverterOptionalString.writeIntoCursor(value.protocolVersion, c);
+      FfiConverterOptionalString.writeIntoCursor(value.agentVersion, c);
     }
     allocationSize(value) {
       return FfiConverterOptionalBytes.allocationSize(value.publicKey) + FfiConverterSequenceString.allocationSize(value.listenAddrs) + FfiConverterSequenceString.allocationSize(value.protocols) + FfiConverterOptionalString.allocationSize(value.observedAddr) + FfiConverterOptionalString.allocationSize(value.protocolVersion) + FfiConverterOptionalString.allocationSize(value.agentVersion);
@@ -395,25 +389,25 @@ export const KnownPeerInfo = (() => {
 })();
 const FfiConverterTypeKnownPeerInfo = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        peerId: FfiConverterString.read(from),
-        addrs: FfiConverterSequenceString.read(from),
-        beaconAddrs: FfiConverterSequenceString.read(from),
-        mdnsAddrs: FfiConverterSequenceString.read(from),
-        beaconLastSeenAgeMs: FfiConverterOptionalUInt64.read(from),
-        mdnsLastSeenAgeMs: FfiConverterOptionalUInt64.read(from),
-        connected: FfiConverterBool.read(from)
+        peerId: FfiConverterString.readFromCursor(c),
+        addrs: FfiConverterSequenceString.readFromCursor(c),
+        beaconAddrs: FfiConverterSequenceString.readFromCursor(c),
+        mdnsAddrs: FfiConverterSequenceString.readFromCursor(c),
+        beaconLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+        mdnsLastSeenAgeMs: FfiConverterOptionalUInt64.readFromCursor(c),
+        connected: FfiConverterBool.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterString.write(value.peerId, into);
-      FfiConverterSequenceString.write(value.addrs, into);
-      FfiConverterSequenceString.write(value.beaconAddrs, into);
-      FfiConverterSequenceString.write(value.mdnsAddrs, into);
-      FfiConverterOptionalUInt64.write(value.beaconLastSeenAgeMs, into);
-      FfiConverterOptionalUInt64.write(value.mdnsLastSeenAgeMs, into);
-      FfiConverterBool.write(value.connected, into);
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.peerId, c);
+      FfiConverterSequenceString.writeIntoCursor(value.addrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.beaconAddrs, c);
+      FfiConverterSequenceString.writeIntoCursor(value.mdnsAddrs, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.beaconLastSeenAgeMs, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.mdnsLastSeenAgeMs, c);
+      FfiConverterBool.writeIntoCursor(value.connected, c);
     }
     allocationSize(value) {
       return FfiConverterString.allocationSize(value.peerId) + FfiConverterSequenceString.allocationSize(value.addrs) + FfiConverterSequenceString.allocationSize(value.beaconAddrs) + FfiConverterSequenceString.allocationSize(value.mdnsAddrs) + FfiConverterOptionalUInt64.allocationSize(value.beaconLastSeenAgeMs) + FfiConverterOptionalUInt64.allocationSize(value.mdnsLastSeenAgeMs) + FfiConverterBool.allocationSize(value.connected);
@@ -443,15 +437,15 @@ export const OpenStreamResult = (() => {
 })();
 const FfiConverterTypeOpenStreamResult = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        connId: FfiConverterUInt64.read(from),
-        streamId: FfiConverterUInt64.read(from)
+        connId: FfiConverterUInt64.readFromCursor(c),
+        streamId: FfiConverterUInt64.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterUInt64.write(value.connId, into);
-      FfiConverterUInt64.write(value.streamId, into);
+    writeIntoCursor(value, c) {
+      FfiConverterUInt64.writeIntoCursor(value.connId, c);
+      FfiConverterUInt64.writeIntoCursor(value.streamId, c);
     }
     allocationSize(value) {
       return FfiConverterUInt64.allocationSize(value.connId) + FfiConverterUInt64.allocationSize(value.streamId);
@@ -481,15 +475,15 @@ export const RelayReservationInfo = (() => {
 })();
 const FfiConverterTypeRelayReservationInfo = (() => {
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
+    readFromCursor(c) {
       return {
-        relayPeerId: FfiConverterString.read(from),
-        expiresUnixSecs: FfiConverterOptionalUInt64.read(from)
+        relayPeerId: FfiConverterString.readFromCursor(c),
+        expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
       };
     }
-    write(value, into) {
-      FfiConverterString.write(value.relayPeerId, into);
-      FfiConverterOptionalUInt64.write(value.expiresUnixSecs, into);
+    writeIntoCursor(value, c) {
+      FfiConverterString.writeIntoCursor(value.relayPeerId, c);
+      FfiConverterOptionalUInt64.writeIntoCursor(value.expiresUnixSecs, c);
     }
     allocationSize(value) {
       return FfiConverterString.allocationSize(value.relayPeerId) + FfiConverterOptionalUInt64.allocationSize(value.expiresUnixSecs);
@@ -514,10 +508,9 @@ export let DiscoverySource = /*#__PURE__*/function (DiscoverySource) {
   return DiscoverySource;
 }({});
 const FfiConverterTypeDiscoverySource = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return DiscoverySource.SignedBeacon;
         case 2:
@@ -526,16 +519,16 @@ const FfiConverterTypeDiscoverySource = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case DiscoverySource.SignedBeacon:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case DiscoverySource.Mdns:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -564,10 +557,9 @@ export let DriverFailureKind = /*#__PURE__*/function (DriverFailureKind) {
   return DriverFailureKind;
 }({});
 const FfiConverterTypeDriverFailureKind = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return DriverFailureKind.Transport;
         case 2:
@@ -580,20 +572,20 @@ const FfiConverterTypeDriverFailureKind = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case DriverFailureKind.Transport:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case DriverFailureKind.Swarm:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
         case DriverFailureKind.Invariant:
-          return ordinalConverter.write(3, into);
+          return c.writeI32(3);
         case DriverFailureKind.Panic:
-          return ordinalConverter.write(4, into);
+          return c.writeI32(4);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -638,10 +630,9 @@ export let EndpointErrorKind = /*#__PURE__*/function (EndpointErrorKind) {
   return EndpointErrorKind;
 }({});
 const FfiConverterTypeEndpointErrorKind = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return EndpointErrorKind.Transport;
         case 2:
@@ -662,28 +653,28 @@ const FfiConverterTypeEndpointErrorKind = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case EndpointErrorKind.Transport:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case EndpointErrorKind.Multistream:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
         case EndpointErrorKind.Identify:
-          return ordinalConverter.write(3, into);
+          return c.writeI32(3);
         case EndpointErrorKind.Ping:
-          return ordinalConverter.write(4, into);
+          return c.writeI32(4);
         case EndpointErrorKind.IdentifyStreamRejected:
-          return ordinalConverter.write(5, into);
+          return c.writeI32(5);
         case EndpointErrorKind.OpenStreamFailed:
-          return ordinalConverter.write(6, into);
+          return c.writeI32(6);
         case EndpointErrorKind.UnsupportedProtocol:
-          return ordinalConverter.write(7, into);
+          return c.writeI32(7);
         case EndpointErrorKind.Driver:
-          return ordinalConverter.write(8, into);
+          return c.writeI32(8);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -1071,37 +1062,36 @@ export const FfiError = (() => {
 
 // FfiConverter for enum FfiError
 const FfiConverterTypeFfiError = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return new FfiError.AlreadyStarted();
         case 2:
           return new FfiError.Stopped();
         case 3:
           return new FfiError.InvalidConfig({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 4:
           return new FfiError.InvalidKey({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 5:
           return new FfiError.InvalidPeerId({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 6:
           return new FfiError.InvalidAddress({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 7:
           return new FfiError.InvalidTopic({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 8:
           return new FfiError.NotPermitted({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 9:
           return new FfiError.Backpressure();
@@ -1109,103 +1099,103 @@ const FfiConverterTypeFfiError = (() => {
           return new FfiError.MessageTooLarge();
         case 11:
           return new FfiError.Transport({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 12:
           return new FfiError.InvalidState({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 13:
           return new FfiError.Internal({
-            detail: FfiConverterString.read(from)
+            detail: FfiConverterString.readFromCursor(c)
           });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value.tag) {
         case FfiError_Tags.AlreadyStarted:
           {
-            ordinalConverter.write(1, into);
+            c.writeI32(1);
             return;
           }
         case FfiError_Tags.Stopped:
           {
-            ordinalConverter.write(2, into);
+            c.writeI32(2);
             return;
           }
         case FfiError_Tags.InvalidConfig:
           {
-            ordinalConverter.write(3, into);
+            c.writeI32(3);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.InvalidKey:
           {
-            ordinalConverter.write(4, into);
+            c.writeI32(4);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.InvalidPeerId:
           {
-            ordinalConverter.write(5, into);
+            c.writeI32(5);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.InvalidAddress:
           {
-            ordinalConverter.write(6, into);
+            c.writeI32(6);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.InvalidTopic:
           {
-            ordinalConverter.write(7, into);
+            c.writeI32(7);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.NotPermitted:
           {
-            ordinalConverter.write(8, into);
+            c.writeI32(8);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.Backpressure:
           {
-            ordinalConverter.write(9, into);
+            c.writeI32(9);
             return;
           }
         case FfiError_Tags.MessageTooLarge:
           {
-            ordinalConverter.write(10, into);
+            c.writeI32(10);
             return;
           }
         case FfiError_Tags.Transport:
           {
-            ordinalConverter.write(11, into);
+            c.writeI32(11);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.InvalidState:
           {
-            ordinalConverter.write(12, into);
+            c.writeI32(12);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case FfiError_Tags.Internal:
           {
-            ordinalConverter.write(13, into);
+            c.writeI32(13);
             const inner = value.inner;
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         default:
@@ -1217,80 +1207,80 @@ const FfiConverterTypeFfiError = (() => {
       switch (value.tag) {
         case FfiError_Tags.AlreadyStarted:
           {
-            return ordinalConverter.allocationSize(1);
+            return 4;
           }
         case FfiError_Tags.Stopped:
           {
-            return ordinalConverter.allocationSize(2);
+            return 4;
           }
         case FfiError_Tags.InvalidConfig:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(3);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.InvalidKey:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(4);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.InvalidPeerId:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(5);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.InvalidAddress:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(6);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.InvalidTopic:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(7);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.NotPermitted:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(8);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.Backpressure:
           {
-            return ordinalConverter.allocationSize(9);
+            return 4;
           }
         case FfiError_Tags.MessageTooLarge:
           {
-            return ordinalConverter.allocationSize(10);
+            return 4;
           }
         case FfiError_Tags.Transport:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(11);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.InvalidState:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(12);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
         case FfiError_Tags.Internal:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(13);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
           }
@@ -1329,10 +1319,9 @@ export let NatErrorKind = /*#__PURE__*/function (NatErrorKind) {
   return NatErrorKind;
 }({});
 const FfiConverterTypeNatErrorKind = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return NatErrorKind.NoPathAvailable;
         case 2:
@@ -1347,22 +1336,22 @@ const FfiConverterTypeNatErrorKind = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case NatErrorKind.NoPathAvailable:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case NatErrorKind.Timeout:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
         case NatErrorKind.DialFailed:
-          return ordinalConverter.write(3, into);
+          return c.writeI32(3);
         case NatErrorKind.Protocol:
-          return ordinalConverter.write(4, into);
+          return c.writeI32(4);
         case NatErrorKind.RelayRefused:
-          return ordinalConverter.write(5, into);
+          return c.writeI32(5);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -1387,10 +1376,9 @@ export let Reachability = /*#__PURE__*/function (Reachability) {
   return Reachability;
 }({});
 const FfiConverterTypeReachability = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return Reachability.Unknown;
         case 2:
@@ -1401,18 +1389,18 @@ const FfiConverterTypeReachability = (() => {
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value) {
         case Reachability.Unknown:
-          return ordinalConverter.write(1, into);
+          return c.writeI32(1);
         case Reachability.Public:
-          return ordinalConverter.write(2, into);
+          return c.writeI32(2);
         case Reachability.Private:
-          return ordinalConverter.write(3, into);
+          return c.writeI32(3);
       }
     }
     allocationSize(value) {
-      return ordinalConverter.allocationSize(0);
+      return 4;
     }
   }
   return new FFIConverter();
@@ -1506,39 +1494,38 @@ export const PathKind = (() => {
 
 // FfiConverter for enum PathKind
 const FfiConverterTypePathKind = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return new PathKind.DirectDialed();
         case 2:
           return new PathKind.DirectPunched();
         case 3:
           return new PathKind.Relayed({
-            relayPeerId: FfiConverterString.read(from)
+            relayPeerId: FfiConverterString.readFromCursor(c)
           });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value.tag) {
         case PathKind_Tags.DirectDialed:
           {
-            ordinalConverter.write(1, into);
+            c.writeI32(1);
             return;
           }
         case PathKind_Tags.DirectPunched:
           {
-            ordinalConverter.write(2, into);
+            c.writeI32(2);
             return;
           }
         case PathKind_Tags.Relayed:
           {
-            ordinalConverter.write(3, into);
+            c.writeI32(3);
             const inner = value.inner;
-            FfiConverterString.write(inner.relayPeerId, into);
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             return;
           }
         default:
@@ -1550,16 +1537,16 @@ const FfiConverterTypePathKind = (() => {
       switch (value.tag) {
         case PathKind_Tags.DirectDialed:
           {
-            return ordinalConverter.allocationSize(1);
+            return 4;
           }
         case PathKind_Tags.DirectPunched:
           {
-            return ordinalConverter.allocationSize(2);
+            return 4;
           }
         case PathKind_Tags.Relayed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(3);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.relayPeerId);
             return size;
           }
@@ -2378,494 +2365,493 @@ export const P2pEvent = (() => {
 
 // FfiConverter for enum P2pEvent
 const FfiConverterTypeP2pEvent = (() => {
-  const ordinalConverter = FfiConverterInt32;
   class FFIConverter extends AbstractFfiConverterByteArray {
-    read(from) {
-      switch (ordinalConverter.read(from)) {
+    readFromCursor(c) {
+      switch (c.readI32()) {
         case 1:
           return new P2pEvent.EventsDropped({
-            dropped: FfiConverterUInt64.read(from),
-            totalDropped: FfiConverterUInt64.read(from)
+            dropped: FfiConverterUInt64.readFromCursor(c),
+            totalDropped: FfiConverterUInt64.readFromCursor(c)
           });
         case 2:
           return new P2pEvent.DriverFailed({
-            kind: FfiConverterTypeDriverFailureKind.read(from),
-            detail: FfiConverterString.read(from)
+            kind: FfiConverterTypeDriverFailureKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 3:
           return new P2pEvent.ConnectionEstablished({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c)
           });
         case 4:
           return new P2pEvent.ConnectionClosed({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c)
           });
         case 5:
           return new P2pEvent.PeerReady({
-            peerId: FfiConverterString.read(from),
-            protocols: FfiConverterSequenceString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            protocols: FfiConverterSequenceString.readFromCursor(c)
           });
         case 6:
           return new P2pEvent.IdentifyReceived({
-            peerId: FfiConverterString.read(from),
-            info: FfiConverterTypeIdentifyInfo.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            info: FfiConverterTypeIdentifyInfo.readFromCursor(c)
           });
         case 7:
           return new P2pEvent.PingRttMeasured({
-            peerId: FfiConverterString.read(from),
-            rttMs: FfiConverterUInt64.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            rttMs: FfiConverterUInt64.readFromCursor(c)
           });
         case 8:
           return new P2pEvent.PingTimeout({
-            peerId: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c)
           });
         case 9:
           return new P2pEvent.StreamReady({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from),
-            streamId: FfiConverterUInt64.read(from),
-            protocolId: FfiConverterString.read(from),
-            initiatedLocally: FfiConverterBool.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c),
+            protocolId: FfiConverterString.readFromCursor(c),
+            initiatedLocally: FfiConverterBool.readFromCursor(c)
           });
         case 10:
           return new P2pEvent.StreamData({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from),
-            streamId: FfiConverterUInt64.read(from),
-            data: FfiConverterArrayBuffer.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c),
+            data: FfiConverterArrayBuffer.readFromCursor(c)
           });
         case 11:
           return new P2pEvent.StreamRemoteWriteClosed({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from),
-            streamId: FfiConverterUInt64.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c)
           });
         case 12:
           return new P2pEvent.StreamClosed({
-            peerId: FfiConverterString.read(from),
-            connId: FfiConverterUInt64.read(from),
-            streamId: FfiConverterUInt64.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            connId: FfiConverterUInt64.readFromCursor(c),
+            streamId: FfiConverterUInt64.readFromCursor(c)
           });
         case 13:
           return new P2pEvent.EndpointError({
-            kind: FfiConverterTypeEndpointErrorKind.read(from),
-            peerId: FfiConverterOptionalString.read(from),
-            connId: FfiConverterOptionalUInt64.read(from),
-            streamId: FfiConverterOptionalUInt64.read(from),
-            detail: FfiConverterString.read(from)
+            kind: FfiConverterTypeEndpointErrorKind.readFromCursor(c),
+            peerId: FfiConverterOptionalString.readFromCursor(c),
+            connId: FfiConverterOptionalUInt64.readFromCursor(c),
+            streamId: FfiConverterOptionalUInt64.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 14:
           return new P2pEvent.ReachabilityChanged({
-            previous: FfiConverterTypeReachability.read(from),
-            current: FfiConverterTypeReachability.read(from),
-            confirmedAddrs: FfiConverterSequenceString.read(from)
+            previous: FfiConverterTypeReachability.readFromCursor(c),
+            current: FfiConverterTypeReachability.readFromCursor(c),
+            confirmedAddrs: FfiConverterSequenceString.readFromCursor(c)
           });
         case 15:
           return new P2pEvent.PublicAddressesChanged({
-            addrs: FfiConverterSequenceString.read(from)
+            addrs: FfiConverterSequenceString.readFromCursor(c)
           });
         case 16:
           return new P2pEvent.RelayReserved({
-            relayPeerId: FfiConverterString.read(from),
-            expiresUnixSecs: FfiConverterOptionalUInt64.read(from)
+            relayPeerId: FfiConverterString.readFromCursor(c),
+            expiresUnixSecs: FfiConverterOptionalUInt64.readFromCursor(c)
           });
         case 17:
           return new P2pEvent.RelayReservationLost({
-            relayPeerId: FfiConverterString.read(from)
+            relayPeerId: FfiConverterString.readFromCursor(c)
           });
         case 18:
           return new P2pEvent.PathEstablished({
-            connectId: FfiConverterUInt64.read(from),
-            peerId: FfiConverterString.read(from),
-            path: FfiConverterTypePathKind.read(from)
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            path: FfiConverterTypePathKind.readFromCursor(c)
           });
         case 19:
           return new P2pEvent.InboundPathEstablished({
-            peerId: FfiConverterString.read(from),
-            path: FfiConverterTypePathKind.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            path: FfiConverterTypePathKind.readFromCursor(c)
           });
         case 20:
           return new P2pEvent.PathUpgraded({
-            connectId: FfiConverterUInt64.read(from),
-            peerId: FfiConverterString.read(from),
-            from: FfiConverterTypePathKind.read(from),
-            to: FfiConverterTypePathKind.read(from)
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            from: FfiConverterTypePathKind.readFromCursor(c),
+            to: FfiConverterTypePathKind.readFromCursor(c)
           });
         case 21:
           return new P2pEvent.HolePunchFailed({
-            connectId: FfiConverterUInt64.read(from),
-            attempt: FfiConverterUInt32.read(from),
-            reason: FfiConverterString.read(from)
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            attempt: FfiConverterUInt32.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
           });
         case 22:
           return new P2pEvent.FellBackToRelay({
-            connectId: FfiConverterUInt64.read(from),
-            peerId: FfiConverterString.read(from)
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c)
           });
         case 23:
           return new P2pEvent.ConnectFailed({
-            connectId: FfiConverterUInt64.read(from),
-            peerId: FfiConverterString.read(from),
-            kind: FfiConverterTypeNatErrorKind.read(from),
-            detail: FfiConverterString.read(from)
+            connectId: FfiConverterUInt64.readFromCursor(c),
+            peerId: FfiConverterString.readFromCursor(c),
+            kind: FfiConverterTypeNatErrorKind.readFromCursor(c),
+            detail: FfiConverterString.readFromCursor(c)
           });
         case 24:
           return new P2pEvent.InboundDirectUpgrade({
-            peerId: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c)
           });
         case 25:
           return new P2pEvent.Message({
-            fromPeerId: FfiConverterString.read(from),
-            topics: FfiConverterSequenceString.read(from),
-            data: FfiConverterArrayBuffer.read(from),
-            seqno: FfiConverterArrayBuffer.read(from),
-            signed: FfiConverterBool.read(from)
+            fromPeerId: FfiConverterString.readFromCursor(c),
+            topics: FfiConverterSequenceString.readFromCursor(c),
+            data: FfiConverterArrayBuffer.readFromCursor(c),
+            seqno: FfiConverterArrayBuffer.readFromCursor(c),
+            signed: FfiConverterBool.readFromCursor(c)
           });
         case 26:
           return new P2pEvent.PeerSubscribed({
-            peerId: FfiConverterString.read(from),
-            topic: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            topic: FfiConverterString.readFromCursor(c)
           });
         case 27:
           return new P2pEvent.PeerUnsubscribed({
-            peerId: FfiConverterString.read(from),
-            topic: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            topic: FfiConverterString.readFromCursor(c)
           });
         case 28:
           return new P2pEvent.PubsubOutboundFailure({
-            peerId: FfiConverterString.read(from),
-            reason: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
           });
         case 29:
           return new P2pEvent.PubsubProtocolViolation({
-            peerId: FfiConverterString.read(from),
-            reason: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
           });
         case 30:
           return new P2pEvent.PeerDiscovered({
-            peerId: FfiConverterString.read(from),
-            addrs: FfiConverterSequenceString.read(from),
-            source: FfiConverterTypeDiscoverySource.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            addrs: FfiConverterSequenceString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
         case 31:
           return new P2pEvent.PeerUpdated({
-            peerId: FfiConverterString.read(from),
-            addrs: FfiConverterSequenceString.read(from),
-            source: FfiConverterTypeDiscoverySource.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            addrs: FfiConverterSequenceString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c)
           });
         case 32:
           return new P2pEvent.PeerExpired({
-            peerId: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c)
           });
         case 33:
           return new P2pEvent.DiscoveryDialFailed({
-            peerId: FfiConverterString.read(from),
-            reason: FfiConverterString.read(from)
+            peerId: FfiConverterString.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c)
           });
         case 34:
           return new P2pEvent.DiscoveryProtocolViolation({
-            peerId: FfiConverterOptionalString.read(from),
-            source: FfiConverterTypeDiscoverySource.read(from),
-            reason: FfiConverterString.read(from),
-            suppressed: FfiConverterUInt32.read(from)
+            peerId: FfiConverterOptionalString.readFromCursor(c),
+            source: FfiConverterTypeDiscoverySource.readFromCursor(c),
+            reason: FfiConverterString.readFromCursor(c),
+            suppressed: FfiConverterUInt32.readFromCursor(c)
           });
         default:
           throw new UniffiInternalError.UnexpectedEnumCase();
       }
     }
-    write(value, into) {
+    writeIntoCursor(value, c) {
       switch (value.tag) {
         case P2pEvent_Tags.EventsDropped:
           {
-            ordinalConverter.write(1, into);
+            c.writeI32(1);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.dropped, into);
-            FfiConverterUInt64.write(inner.totalDropped, into);
+            FfiConverterUInt64.writeIntoCursor(inner.dropped, c);
+            FfiConverterUInt64.writeIntoCursor(inner.totalDropped, c);
             return;
           }
         case P2pEvent_Tags.DriverFailed:
           {
-            ordinalConverter.write(2, into);
+            c.writeI32(2);
             const inner = value.inner;
-            FfiConverterTypeDriverFailureKind.write(inner.kind, into);
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterTypeDriverFailureKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case P2pEvent_Tags.ConnectionEstablished:
           {
-            ordinalConverter.write(3, into);
+            c.writeI32(3);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
             return;
           }
         case P2pEvent_Tags.ConnectionClosed:
           {
-            ordinalConverter.write(4, into);
+            c.writeI32(4);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
             return;
           }
         case P2pEvent_Tags.PeerReady:
           {
-            ordinalConverter.write(5, into);
+            c.writeI32(5);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterSequenceString.write(inner.protocols, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.protocols, c);
             return;
           }
         case P2pEvent_Tags.IdentifyReceived:
           {
-            ordinalConverter.write(6, into);
+            c.writeI32(6);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterTypeIdentifyInfo.write(inner.info, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeIdentifyInfo.writeIntoCursor(inner.info, c);
             return;
           }
         case P2pEvent_Tags.PingRttMeasured:
           {
-            ordinalConverter.write(7, into);
+            c.writeI32(7);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.rttMs, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.rttMs, c);
             return;
           }
         case P2pEvent_Tags.PingTimeout:
           {
-            ordinalConverter.write(8, into);
+            c.writeI32(8);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.StreamReady:
           {
-            ordinalConverter.write(9, into);
+            c.writeI32(9);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
-            FfiConverterUInt64.write(inner.streamId, into);
-            FfiConverterString.write(inner.protocolId, into);
-            FfiConverterBool.write(inner.initiatedLocally, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterString.writeIntoCursor(inner.protocolId, c);
+            FfiConverterBool.writeIntoCursor(inner.initiatedLocally, c);
             return;
           }
         case P2pEvent_Tags.StreamData:
           {
-            ordinalConverter.write(10, into);
+            c.writeI32(10);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
-            FfiConverterUInt64.write(inner.streamId, into);
-            FfiConverterArrayBuffer.write(inner.data, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
             return;
           }
         case P2pEvent_Tags.StreamRemoteWriteClosed:
           {
-            ordinalConverter.write(11, into);
+            c.writeI32(11);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
-            FfiConverterUInt64.write(inner.streamId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
             return;
           }
         case P2pEvent_Tags.StreamClosed:
           {
-            ordinalConverter.write(12, into);
+            c.writeI32(12);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterUInt64.write(inner.connId, into);
-            FfiConverterUInt64.write(inner.streamId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterUInt64.writeIntoCursor(inner.streamId, c);
             return;
           }
         case P2pEvent_Tags.EndpointError:
           {
-            ordinalConverter.write(13, into);
+            c.writeI32(13);
             const inner = value.inner;
-            FfiConverterTypeEndpointErrorKind.write(inner.kind, into);
-            FfiConverterOptionalString.write(inner.peerId, into);
-            FfiConverterOptionalUInt64.write(inner.connId, into);
-            FfiConverterOptionalUInt64.write(inner.streamId, into);
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterTypeEndpointErrorKind.writeIntoCursor(inner.kind, c);
+            FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.connId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.streamId, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case P2pEvent_Tags.ReachabilityChanged:
           {
-            ordinalConverter.write(14, into);
+            c.writeI32(14);
             const inner = value.inner;
-            FfiConverterTypeReachability.write(inner.previous, into);
-            FfiConverterTypeReachability.write(inner.current, into);
-            FfiConverterSequenceString.write(inner.confirmedAddrs, into);
+            FfiConverterTypeReachability.writeIntoCursor(inner.previous, c);
+            FfiConverterTypeReachability.writeIntoCursor(inner.current, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.confirmedAddrs, c);
             return;
           }
         case P2pEvent_Tags.PublicAddressesChanged:
           {
-            ordinalConverter.write(15, into);
+            c.writeI32(15);
             const inner = value.inner;
-            FfiConverterSequenceString.write(inner.addrs, into);
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
             return;
           }
         case P2pEvent_Tags.RelayReserved:
           {
-            ordinalConverter.write(16, into);
+            c.writeI32(16);
             const inner = value.inner;
-            FfiConverterString.write(inner.relayPeerId, into);
-            FfiConverterOptionalUInt64.write(inner.expiresUnixSecs, into);
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
+            FfiConverterOptionalUInt64.writeIntoCursor(inner.expiresUnixSecs, c);
             return;
           }
         case P2pEvent_Tags.RelayReservationLost:
           {
-            ordinalConverter.write(17, into);
+            c.writeI32(17);
             const inner = value.inner;
-            FfiConverterString.write(inner.relayPeerId, into);
+            FfiConverterString.writeIntoCursor(inner.relayPeerId, c);
             return;
           }
         case P2pEvent_Tags.PathEstablished:
           {
-            ordinalConverter.write(18, into);
+            c.writeI32(18);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.connectId, into);
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterTypePathKind.write(inner.path, into);
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
             return;
           }
         case P2pEvent_Tags.InboundPathEstablished:
           {
-            ordinalConverter.write(19, into);
+            c.writeI32(19);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterTypePathKind.write(inner.path, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.path, c);
             return;
           }
         case P2pEvent_Tags.PathUpgraded:
           {
-            ordinalConverter.write(20, into);
+            c.writeI32(20);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.connectId, into);
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterTypePathKind.write(inner.from, into);
-            FfiConverterTypePathKind.write(inner.to, into);
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.from, c);
+            FfiConverterTypePathKind.writeIntoCursor(inner.to, c);
             return;
           }
         case P2pEvent_Tags.HolePunchFailed:
           {
-            ordinalConverter.write(21, into);
+            c.writeI32(21);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.connectId, into);
-            FfiConverterUInt32.write(inner.attempt, into);
-            FfiConverterString.write(inner.reason, into);
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterUInt32.writeIntoCursor(inner.attempt, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
         case P2pEvent_Tags.FellBackToRelay:
           {
-            ordinalConverter.write(22, into);
+            c.writeI32(22);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.connectId, into);
-            FfiConverterString.write(inner.peerId, into);
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.ConnectFailed:
           {
-            ordinalConverter.write(23, into);
+            c.writeI32(23);
             const inner = value.inner;
-            FfiConverterUInt64.write(inner.connectId, into);
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterTypeNatErrorKind.write(inner.kind, into);
-            FfiConverterString.write(inner.detail, into);
+            FfiConverterUInt64.writeIntoCursor(inner.connectId, c);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeNatErrorKind.writeIntoCursor(inner.kind, c);
+            FfiConverterString.writeIntoCursor(inner.detail, c);
             return;
           }
         case P2pEvent_Tags.InboundDirectUpgrade:
           {
-            ordinalConverter.write(24, into);
+            c.writeI32(24);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.Message:
           {
-            ordinalConverter.write(25, into);
+            c.writeI32(25);
             const inner = value.inner;
-            FfiConverterString.write(inner.fromPeerId, into);
-            FfiConverterSequenceString.write(inner.topics, into);
-            FfiConverterArrayBuffer.write(inner.data, into);
-            FfiConverterArrayBuffer.write(inner.seqno, into);
-            FfiConverterBool.write(inner.signed, into);
+            FfiConverterString.writeIntoCursor(inner.fromPeerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.topics, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.data, c);
+            FfiConverterArrayBuffer.writeIntoCursor(inner.seqno, c);
+            FfiConverterBool.writeIntoCursor(inner.signed, c);
             return;
           }
         case P2pEvent_Tags.PeerSubscribed:
           {
-            ordinalConverter.write(26, into);
+            c.writeI32(26);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterString.write(inner.topic, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.topic, c);
             return;
           }
         case P2pEvent_Tags.PeerUnsubscribed:
           {
-            ordinalConverter.write(27, into);
+            c.writeI32(27);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterString.write(inner.topic, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.topic, c);
             return;
           }
         case P2pEvent_Tags.PubsubOutboundFailure:
           {
-            ordinalConverter.write(28, into);
+            c.writeI32(28);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterString.write(inner.reason, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
         case P2pEvent_Tags.PubsubProtocolViolation:
           {
-            ordinalConverter.write(29, into);
+            c.writeI32(29);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterString.write(inner.reason, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
         case P2pEvent_Tags.PeerDiscovered:
           {
-            ordinalConverter.write(30, into);
+            c.writeI32(30);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterSequenceString.write(inner.addrs, into);
-            FfiConverterTypeDiscoverySource.write(inner.source, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
             return;
           }
         case P2pEvent_Tags.PeerUpdated:
           {
-            ordinalConverter.write(31, into);
+            c.writeI32(31);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterSequenceString.write(inner.addrs, into);
-            FfiConverterTypeDiscoverySource.write(inner.source, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterSequenceString.writeIntoCursor(inner.addrs, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
             return;
           }
         case P2pEvent_Tags.PeerExpired:
           {
-            ordinalConverter.write(32, into);
+            c.writeI32(32);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
             return;
           }
         case P2pEvent_Tags.DiscoveryDialFailed:
           {
-            ordinalConverter.write(33, into);
+            c.writeI32(33);
             const inner = value.inner;
-            FfiConverterString.write(inner.peerId, into);
-            FfiConverterString.write(inner.reason, into);
+            FfiConverterString.writeIntoCursor(inner.peerId, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
             return;
           }
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
-            ordinalConverter.write(34, into);
+            c.writeI32(34);
             const inner = value.inner;
-            FfiConverterOptionalString.write(inner.peerId, into);
-            FfiConverterTypeDiscoverySource.write(inner.source, into);
-            FfiConverterString.write(inner.reason, into);
-            FfiConverterUInt32.write(inner.suppressed, into);
+            FfiConverterOptionalString.writeIntoCursor(inner.peerId, c);
+            FfiConverterTypeDiscoverySource.writeIntoCursor(inner.source, c);
+            FfiConverterString.writeIntoCursor(inner.reason, c);
+            FfiConverterUInt32.writeIntoCursor(inner.suppressed, c);
             return;
           }
         default:
@@ -2878,7 +2864,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.EventsDropped:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(1);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.dropped);
             size += FfiConverterUInt64.allocationSize(inner.totalDropped);
             return size;
@@ -2886,7 +2872,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.DriverFailed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(2);
+            let size = 4;
             size += FfiConverterTypeDriverFailureKind.allocationSize(inner.kind);
             size += FfiConverterString.allocationSize(inner.detail);
             return size;
@@ -2894,7 +2880,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.ConnectionEstablished:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(3);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             return size;
@@ -2902,7 +2888,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.ConnectionClosed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(4);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             return size;
@@ -2910,7 +2896,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerReady:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(5);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterSequenceString.allocationSize(inner.protocols);
             return size;
@@ -2918,7 +2904,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.IdentifyReceived:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(6);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterTypeIdentifyInfo.allocationSize(inner.info);
             return size;
@@ -2926,7 +2912,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PingRttMeasured:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(7);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.rttMs);
             return size;
@@ -2934,14 +2920,14 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PingTimeout:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(8);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             return size;
           }
         case P2pEvent_Tags.StreamReady:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(9);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             size += FfiConverterUInt64.allocationSize(inner.streamId);
@@ -2952,7 +2938,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.StreamData:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(10);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             size += FfiConverterUInt64.allocationSize(inner.streamId);
@@ -2962,7 +2948,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.StreamRemoteWriteClosed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(11);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             size += FfiConverterUInt64.allocationSize(inner.streamId);
@@ -2971,7 +2957,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.StreamClosed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(12);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterUInt64.allocationSize(inner.connId);
             size += FfiConverterUInt64.allocationSize(inner.streamId);
@@ -2980,7 +2966,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.EndpointError:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(13);
+            let size = 4;
             size += FfiConverterTypeEndpointErrorKind.allocationSize(inner.kind);
             size += FfiConverterOptionalString.allocationSize(inner.peerId);
             size += FfiConverterOptionalUInt64.allocationSize(inner.connId);
@@ -2991,7 +2977,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.ReachabilityChanged:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(14);
+            let size = 4;
             size += FfiConverterTypeReachability.allocationSize(inner.previous);
             size += FfiConverterTypeReachability.allocationSize(inner.current);
             size += FfiConverterSequenceString.allocationSize(inner.confirmedAddrs);
@@ -3000,14 +2986,14 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PublicAddressesChanged:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(15);
+            let size = 4;
             size += FfiConverterSequenceString.allocationSize(inner.addrs);
             return size;
           }
         case P2pEvent_Tags.RelayReserved:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(16);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.relayPeerId);
             size += FfiConverterOptionalUInt64.allocationSize(inner.expiresUnixSecs);
             return size;
@@ -3015,14 +3001,14 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.RelayReservationLost:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(17);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.relayPeerId);
             return size;
           }
         case P2pEvent_Tags.PathEstablished:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(18);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.connectId);
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterTypePathKind.allocationSize(inner.path);
@@ -3031,7 +3017,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.InboundPathEstablished:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(19);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterTypePathKind.allocationSize(inner.path);
             return size;
@@ -3039,7 +3025,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PathUpgraded:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(20);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.connectId);
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterTypePathKind.allocationSize(inner.from);
@@ -3049,7 +3035,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.HolePunchFailed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(21);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.connectId);
             size += FfiConverterUInt32.allocationSize(inner.attempt);
             size += FfiConverterString.allocationSize(inner.reason);
@@ -3058,7 +3044,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.FellBackToRelay:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(22);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.connectId);
             size += FfiConverterString.allocationSize(inner.peerId);
             return size;
@@ -3066,7 +3052,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.ConnectFailed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(23);
+            let size = 4;
             size += FfiConverterUInt64.allocationSize(inner.connectId);
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterTypeNatErrorKind.allocationSize(inner.kind);
@@ -3076,14 +3062,14 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.InboundDirectUpgrade:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(24);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             return size;
           }
         case P2pEvent_Tags.Message:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(25);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.fromPeerId);
             size += FfiConverterSequenceString.allocationSize(inner.topics);
             size += FfiConverterArrayBuffer.allocationSize(inner.data);
@@ -3094,7 +3080,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerSubscribed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(26);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterString.allocationSize(inner.topic);
             return size;
@@ -3102,7 +3088,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerUnsubscribed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(27);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterString.allocationSize(inner.topic);
             return size;
@@ -3110,7 +3096,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PubsubOutboundFailure:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(28);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterString.allocationSize(inner.reason);
             return size;
@@ -3118,7 +3104,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PubsubProtocolViolation:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(29);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterString.allocationSize(inner.reason);
             return size;
@@ -3126,7 +3112,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerDiscovered:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(30);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterSequenceString.allocationSize(inner.addrs);
             size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
@@ -3135,7 +3121,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerUpdated:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(31);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterSequenceString.allocationSize(inner.addrs);
             size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
@@ -3144,14 +3130,14 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.PeerExpired:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(32);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             return size;
           }
         case P2pEvent_Tags.DiscoveryDialFailed:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(33);
+            let size = 4;
             size += FfiConverterString.allocationSize(inner.peerId);
             size += FfiConverterString.allocationSize(inner.reason);
             return size;
@@ -3159,7 +3145,7 @@ const FfiConverterTypeP2pEvent = (() => {
         case P2pEvent_Tags.DiscoveryProtocolViolation:
           {
             const inner = value.inner;
-            let size = ordinalConverter.allocationSize(34);
+            let size = 4;
             size += FfiConverterOptionalString.allocationSize(inner.peerId);
             size += FfiConverterTypeDiscoverySource.allocationSize(inner.source);
             size += FfiConverterString.allocationSize(inner.reason);
@@ -3175,53 +3161,53 @@ const FfiConverterTypeP2pEvent = (() => {
 })();
 
 /**
- * Listener implemented by the embedding runtime.
+ * Doorbell implemented by the embedding runtime.
  */
 
 /**
- * Listener implemented by the embedding runtime.
+ * Doorbell implemented by the embedding runtime.
  */
-export class P2pEventListenerImpl extends UniffiAbstractObject {
-  [uniffiTypeNameSymbol] = "P2pEventListenerImpl";
+export class P2pEventDoorbellImpl extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "P2pEventDoorbellImpl";
   // No primary constructor declared for this class.
   constructor(pointer) {
     super();
     this[pointerLiteralSymbol] = pointer;
-    this[destructorGuardSymbol] = uniffiTypeP2pEventListenerImplObjectFactory.bless(pointer);
+    this[destructorGuardSymbol] = uniffiTypeP2pEventDoorbellImplObjectFactory.bless(pointer);
   }
 
   /**
-   * Receives one converted native event.
+   * Reports that synchronous event draining can make progress.
    */
-  onEvent(event) {
+  onEventsReady() {
     uniffiCaller.rustCall(/*caller:*/callStatus => {
-      nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2peventlistener_on_event(uniffiTypeP2pEventListenerImplObjectFactory.clonePointer(this), FfiConverterTypeP2pEvent.lower(event, nativeModule().rustbuffer_alloc), callStatus);
+      nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2peventdoorbell_on_events_ready(uniffiTypeP2pEventDoorbellImplObjectFactory.clonePointer(this), callStatus);
     }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
   }
   uniffiDestroy() {
     const ptr = this[destructorGuardSymbol];
     if (ptr !== undefined) {
-      const pointer = uniffiTypeP2pEventListenerImplObjectFactory.pointer(this);
-      uniffiTypeP2pEventListenerImplObjectFactory.freePointer(pointer);
-      uniffiTypeP2pEventListenerImplObjectFactory.unbless(ptr);
+      const pointer = uniffiTypeP2pEventDoorbellImplObjectFactory.pointer(this);
+      uniffiTypeP2pEventDoorbellImplObjectFactory.freePointer(pointer);
+      uniffiTypeP2pEventDoorbellImplObjectFactory.unbless(ptr);
       delete this[destructorGuardSymbol];
     }
   }
   static instanceOf(obj_) {
-    return uniffiTypeP2pEventListenerImplObjectFactory.isConcreteType(obj_);
+    return uniffiTypeP2pEventDoorbellImplObjectFactory.isConcreteType(obj_);
   }
 }
-const uniffiTypeP2pEventListenerImplObjectFactory = (() => {
+const uniffiTypeP2pEventDoorbellImplObjectFactory = (() => {
   return {
     create(pointer) {
-      const instance = Object.create(P2pEventListenerImpl.prototype);
+      const instance = Object.create(P2pEventDoorbellImpl.prototype);
       instance[pointerLiteralSymbol] = pointer;
       instance[destructorGuardSymbol] = this.bless(pointer);
-      instance[uniffiTypeNameSymbol] = "P2pEventListenerImpl";
+      instance[uniffiTypeNameSymbol] = "P2pEventDoorbellImpl";
       return instance;
     },
     bless(p) {
-      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_p2peventlistener_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
+      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_p2peventdoorbell_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
     },
     unbless(ptr_) {
       ptr_.markDestroyed();
@@ -3234,29 +3220,29 @@ const uniffiTypeP2pEventListenerImplObjectFactory = (() => {
     },
     clonePointer(obj_) {
       const pointer = this.pointer(obj_);
-      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_minip2p_ffi_fn_clone_p2peventlistener(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_minip2p_ffi_fn_clone_p2peventdoorbell(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
     },
     freePointer(pointer) {
-      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_minip2p_ffi_fn_free_p2peventlistener(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_minip2p_ffi_fn_free_p2peventdoorbell(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
     },
     isConcreteType(obj_) {
-      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "P2pEventListenerImpl";
+      return obj_[destructorGuardSymbol] && obj_[uniffiTypeNameSymbol] === "P2pEventDoorbellImpl";
     }
   };
 })();
-const FfiConverterTypeP2pEventListener = new FfiConverterObjectWithCallbacks(uniffiTypeP2pEventListenerImplObjectFactory);
+const FfiConverterTypeP2pEventDoorbell = new FfiConverterObjectWithCallbacks(uniffiTypeP2pEventDoorbellImplObjectFactory);
 
-// Add a vtable for the callbacks that go in P2pEventListener.
+// Add a vtable for the callbacks that go in P2pEventDoorbell.
 
 // Put the implementation in a struct so we don't pollute the top-level namespace
-const uniffiCallbackInterfaceP2pEventListener = {
+const uniffiCallbackInterfaceP2pEventDoorbell = {
   // Create the VTable using a series of closures.
   // ts automatically converts these into C callback functions.
   vtable: {
-    on_event: (uniffiHandle, event) => {
+    on_events_ready: uniffiHandle => {
       const uniffiMakeCall = () => {
-        const jsCallback = FfiConverterTypeP2pEventListener.lift(uniffiHandle);
-        return jsCallback.onEvent(FfiConverterTypeP2pEvent.lift(event));
+        const jsCallback = FfiConverterTypeP2pEventDoorbell.lift(uniffiHandle);
+        return jsCallback.onEventsReady();
       };
       const uniffiResult = UniffiResult.ready();
       const uniffiHandleSuccess = obj => {};
@@ -3268,14 +3254,14 @@ const uniffiCallbackInterfaceP2pEventListener = {
     },
     uniffi_free: uniffiHandle => {
       // this will throw a stale handle error if the handle isn't found.
-      FfiConverterTypeP2pEventListener.drop(uniffiHandle);
+      FfiConverterTypeP2pEventDoorbell.drop(uniffiHandle);
     },
     uniffi_clone: uniffiHandle => {
-      return FfiConverterTypeP2pEventListener.clone(uniffiHandle);
+      return FfiConverterTypeP2pEventDoorbell.clone(uniffiHandle);
     }
   },
   register: () => {
-    nativeModule().ubrn_uniffi_minip2p_ffi_fn_init_callback_vtable_p2peventlistener(uniffiCallbackInterfaceP2pEventListener.vtable);
+    nativeModule().ubrn_uniffi_minip2p_ffi_fn_init_callback_vtable_p2peventdoorbell(uniffiCallbackInterfaceP2pEventDoorbell.vtable);
   }
 };
 
@@ -3293,11 +3279,7 @@ const uniffiCallbackInterfaceP2pEventListener = {
 export class P2pEndpoint extends UniffiAbstractObject {
   [uniffiTypeNameSymbol] = "P2pEndpoint";
   /**
-   * Validates the secret key and `config`, binds its transports, and creates
-   * an endpoint.
-   *
-   * The endpoint begins in the created state and owns its bound sockets,
-   * but does not run a background driver until explicitly started.
+   * Creates an endpoint after validating configuration and binding sockets.
    */
   constructor(secretKey, config) /*throws*/{
     super();
@@ -3309,7 +3291,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Resets and forgets an application stream.
+   * Forgets a stream.
    */
   abandonStream(peerId, streamId) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3318,18 +3300,17 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns the active inbound relay reservation.
+   * Returns the active relay reservation.
    */
   activeReservation() /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterOptionalTypeRelayReservationInfo.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_active_reservation(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterOptionalTypeRelayReservationInfo.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
@@ -3342,10 +3323,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Cancels a known connection attempt; unknown ids are an idempotent no-op.
-   *
-   * Queued connection events are suppressed when possible. A listener
-   * callback that already won the dispatch race may still arrive.
+   * Cancels a connection attempt.
    */
   cancelConnect(id) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3354,7 +3332,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Half-closes the local write side of an application stream.
+   * Half-closes a stream's write side.
    */
   closeStreamWrite(peerId, streamId) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3363,7 +3341,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Starts a connection attempt toward a peer without known direct addresses.
+   * Starts a connection attempt.
    */
   connect(peerId) /*throws*/{
     return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3372,8 +3350,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Starts a connection attempt toward a direct `/quic-v1` or `/tcp` peer
-   * address.
+   * Starts a direct-address connection attempt.
    */
   connectAddr(address) /*throws*/{
     return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3382,7 +3359,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Starts a NAT connection attempt using an explicit ordered address set.
+   * Starts a connection attempt with explicit addresses.
    */
   connectWithAddrs(peerId, addresses) /*throws*/{
     return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3391,37 +3368,35 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns peers with an established QUIC, TCP, or circuit connection.
+   * Returns connected peers.
    */
   connectedPeers() /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterSequenceString.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_connected_peers(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterSequenceString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Dials a direct peer address on every applicable local address family.
+   * Dials on all applicable address families.
    */
   dial(address) /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterSequenceUInt64.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_dial(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterString.lower(address, nativeModule().rustbuffer_alloc), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterSequenceUInt64.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Dials a direct peer address using IPv4.
+   * Dials using IPv4.
    */
   dialIp4(address) /*throws*/{
     return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3430,7 +3405,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Dials a direct peer address using IPv6.
+   * Dials using IPv6.
    */
   dialIp6(address) /*throws*/{
     return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3439,12 +3414,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Closes the active connection to `peer_id`.
-   *
-   * Cancelling a connection attempt suppresses that attempt's progress
-   * events, but cannot retract a transport connection that has already
-   * completed. Call this method when cancellation must also close an
-   * established connection.
+   * Disconnects a peer.
    */
   disconnect(peerId) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3453,22 +3423,35 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns the discovery driver's monotonic clock in milliseconds.
+   * Returns the discovery clock.
    */
   discoveryNowMs() /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterOptionalUInt64.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_discovery_now_ms(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterOptionalUInt64.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Returns whether Identify has completed for `peer_id`.
+   * Pulls at most `limit` queued events in order.
+   */
+  drainEvents(limit) {
+    const __rb = uniffiCaller.rustCall(/*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_drain_events(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterUInt32.lower(limit, nativeModule().rustbuffer_alloc), callStatus);
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterSequenceTypeP2pEvent.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
+  }
+
+  /**
+   * Returns whether Identify completed for a peer.
    */
   isPeerReady(peerId) /*throws*/{
     return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3477,10 +3460,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns whether the background driver is accepting work.
-   *
-   * This becomes `false` when shutdown is requested. Use
-   * [`P2pEndpoint::wait_stopped`] to observe complete driver exit.
+   * Returns whether the driver accepts work.
    */
   isRunning() {
     return FfiConverterBool.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
@@ -3489,97 +3469,91 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns the shared discovery address-book snapshot.
+   * Returns the discovery address book.
    */
   knownPeers() /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterSequenceTypeKnownPeerInfo.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_known_peers(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterSequenceTypeKnownPeerInfo.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Returns the bound QUIC or TCP peer addresses.
+   * Returns bound peer addresses.
    */
   listenAddrs() {
-    return (__rb => {
-      try {
-        return FfiConverterSequenceString.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCall(/*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_listen_addrs(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterSequenceString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Opens a negotiated application stream and returns its opaque id.
+   * Opens an application stream.
    */
   openStream(peerId, protocolId) /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterTypeOpenStreamResult.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_open_stream(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterString.lower(peerId, nativeModule().rustbuffer_alloc), FfiConverterString.lower(protocolId, nativeModule().rustbuffer_alloc), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterTypeOpenStreamResult.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Returns the current usable NAT-orchestrated path to `peer_id`.
+   * Returns the current path to a peer.
    */
   path(peerId) /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterOptionalTypePathKind.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_path(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterString.lower(peerId, nativeModule().rustbuffer_alloc), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterOptionalTypePathKind.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Returns the local peer ID as legacy base58 text.
+   * Returns the local peer ID.
    */
   peerId() {
-    return (__rb => {
-      try {
-        return FfiConverterString.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCall(/*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCall(/*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_peer_id(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterString.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Returns the latest Identify snapshot for `peer_id`.
+   * Returns the latest Identify snapshot.
    */
   peerInfo(peerId) /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterOptionalTypeIdentifyInfo.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_peer_info(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterString.lower(peerId, nativeModule().rustbuffer_alloc), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterOptionalTypeIdentifyInfo.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Sends an explicit ping; completion arrives as a ping event.
+   * Sends an explicit ping.
    */
   ping(peerId) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3588,7 +3562,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Publishes one application payload.
+   * Publishes one payload.
    */
   publish(topic, data) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3597,22 +3571,21 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Returns the current AutoNAT reachability verdict.
+   * Returns the current reachability verdict.
    */
   reachability() /*throws*/{
-    return (__rb => {
-      try {
-        return FfiConverterTypeReachability.lift(__rb);
-      } finally {
-        nativeModule().rustbuffer_free(__rb);
-      }
-    })(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
+    const __rb = uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
       return nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_reachability(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), callStatus);
-    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString)));
+    }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
+    try {
+      return FfiConverterTypeReachability.lift(__rb);
+    } finally {
+      nativeModule().rustbuffer_free(__rb);
+    }
   }
 
   /**
-   * Resets an application stream while retaining later close events.
+   * Resets a stream.
    */
   resetStream(peerId, streamId) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3621,7 +3594,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Sends one byte chunk on an application stream.
+   * Sends bytes on a stream.
    */
   sendStream(peerId, streamId, data) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
@@ -3630,7 +3603,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Selects active or idle driver polling without changing delivery semantics.
+   * Selects active or idle polling.
    */
   setActive(active) {
     uniffiCaller.rustCall(/*caller:*/callStatus => {
@@ -3639,16 +3612,16 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Starts the detached background endpoint driver.
+   * Starts the detached driver and registers its doorbell.
    */
-  start(listener) /*throws*/{
+  start(doorbell) /*throws*/{
     uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeFfiError.lift.bind(FfiConverterTypeFfiError), /*caller:*/callStatus => {
-      nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_start(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterTypeP2pEventListener.lower(listener, nativeModule().rustbuffer_alloc), callStatus);
+      nativeModule().ubrn_uniffi_minip2p_ffi_fn_method_p2pendpoint_start(uniffiTypeP2pEndpointObjectFactory.clonePointer(this), FfiConverterTypeP2pEventDoorbell.lower(doorbell, nativeModule().rustbuffer_alloc), callStatus);
     }, /*liftString:*/FfiConverterString.lift.bind(FfiConverterString));
   }
 
   /**
-   * Requests shutdown without waiting for an in-flight callback.
+   * Requests shutdown.
    */
   stop() {
     uniffiCaller.rustCall(/*caller:*/callStatus => {
@@ -3675,14 +3648,7 @@ export class P2pEndpoint extends UniffiAbstractObject {
   }
 
   /**
-   * Waits up to `timeout_ms` for the endpoint to reach the stopped state.
-   *
-   * A newly created endpoint still owns bound sockets, so this returns
-   * `false` until `stop` releases it. For a running endpoint, `stop` only
-   * requests shutdown and this waits for the driver exit cleanup.
-   *
-   * Calling this from a listener callback would wait on the callback's own
-   * driver thread, so that case returns `false` immediately.
+   * Waits for complete driver shutdown.
    */
   waitStopped(timeoutMs) {
     return FfiConverterBool.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
@@ -3767,6 +3733,9 @@ const FfiConverterOptionalTypeRelayReservationInfo = new FfiConverterOptional(Ff
 // FfiConverter for Array<bigint>
 const FfiConverterSequenceUInt64 = new FfiConverterArray(FfiConverterUInt64);
 
+// FfiConverter for Array<P2pEvent>
+const FfiConverterSequenceTypeP2pEvent = new FfiConverterArray(FfiConverterTypeP2pEvent);
+
 // FfiConverter for Array<KnownPeerInfo>
 const FfiConverterSequenceTypeKnownPeerInfo = new FfiConverterArray(FfiConverterTypeKnownPeerInfo);
 
@@ -3794,7 +3763,7 @@ function uniffiEnsureInitialized() {
   if (bindingsContractVersion !== scaffoldingContractVersion) {
     throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_func_circuit_address() !== 35059) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_func_circuit_address() !== 35260) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_func_circuit_address");
   }
   if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_func_generate_secret_key() !== 44400) {
@@ -3803,97 +3772,100 @@ function uniffiEnsureInitialized() {
   if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_func_peer_id_from_secret_key() !== 8962) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_func_peer_id_from_secret_key");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_constructor_p2pendpoint_new() !== 64534) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_constructor_p2pendpoint_new() !== 8152) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_constructor_p2pendpoint_new");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_abandon_stream() !== 60482) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_abandon_stream() !== 2693) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_abandon_stream");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_active_reservation() !== 46981) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_active_reservation() !== 6405) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_active_reservation");
   }
   if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_add_protocol() !== 12280) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_add_protocol");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_cancel_connect() !== 62501) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_cancel_connect() !== 24195) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_cancel_connect");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_close_stream_write() !== 26147) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_close_stream_write() !== 17994) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_close_stream_write");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect() !== 60427) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect() !== 42064) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_addr() !== 27341) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_addr() !== 56611) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_addr");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_with_addrs() !== 44153) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_with_addrs() !== 2062) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_connect_with_addrs");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connected_peers() !== 49290) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_connected_peers() !== 64148) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_connected_peers");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial() !== 47576) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial() !== 35216) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip4() !== 48021) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip4() !== 54241) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip4");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip6() !== 24748) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip6() !== 3676) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_dial_ip6");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_disconnect() !== 59922) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_disconnect() !== 23975) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_disconnect");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_discovery_now_ms() !== 8975) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_discovery_now_ms() !== 14313) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_discovery_now_ms");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_peer_ready() !== 1184) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_drain_events() !== 30807) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_drain_events");
+  }
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_peer_ready() !== 30114) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_peer_ready");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_running() !== 42546) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_running() !== 42027) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_is_running");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_known_peers() !== 27328) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_known_peers() !== 8123) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_known_peers");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_listen_addrs() !== 645) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_listen_addrs() !== 43494) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_listen_addrs");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_open_stream() !== 18245) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_open_stream() !== 49419) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_open_stream");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_path() !== 58210) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_path() !== 6891) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_path");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_id() !== 34289) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_id() !== 42474) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_id");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_info() !== 2761) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_info() !== 57911) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_peer_info");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_ping() !== 64674) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_ping() !== 62457) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_ping");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_publish() !== 42508) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_publish() !== 19337) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_publish");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_reachability() !== 24757) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_reachability() !== 22554) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_reachability");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_reset_stream() !== 52801) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_reset_stream() !== 10950) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_reset_stream");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_send_stream() !== 28787) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_send_stream() !== 64427) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_send_stream");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_set_active() !== 14047) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_set_active() !== 95) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_set_active");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_start() !== 28557) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_start() !== 31285) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_start");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_stop() !== 61952) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_stop() !== 11062) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_stop");
   }
   if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_subscribe() !== 55119) {
@@ -3902,13 +3874,13 @@ function uniffiEnsureInitialized() {
   if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_unsubscribe() !== 32264) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_unsubscribe");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_wait_stopped() !== 3101) {
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2pendpoint_wait_stopped() !== 14108) {
     throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2pendpoint_wait_stopped");
   }
-  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2peventlistener_on_event() !== 45831) {
-    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2peventlistener_on_event");
+  if (nativeModule().ubrn_uniffi_minip2p_ffi_checksum_method_p2peventdoorbell_on_events_ready() !== 57338) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_minip2p_ffi_checksum_method_p2peventdoorbell_on_events_ready");
   }
-  uniffiCallbackInterfaceP2pEventListener.register();
+  uniffiCallbackInterfaceP2pEventDoorbell.register();
 }
 export default Object.freeze({
   initialize: uniffiEnsureInitialized,
@@ -3926,7 +3898,7 @@ export default Object.freeze({
     FfiConverterTypeOpenStreamResult,
     FfiConverterTypeP2pEndpoint,
     FfiConverterTypeP2pEvent,
-    FfiConverterTypeP2pEventListener,
+    FfiConverterTypeP2pEventDoorbell,
     FfiConverterTypePathKind,
     FfiConverterTypePubsubRouter,
     FfiConverterTypeReachability,