diff --git a/Cargo.lock b/Cargo.lock
index 2c1e5dee84f..6d84fb74fc4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -11584,23 +11584,23 @@ dependencies = [
 [[package]]
 name = "uniffi"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "camino",
  "cargo_metadata",
  "clap",
- "uniffi_bindgen 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_core 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_bindgen 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_core 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
 name = "uniffi-bindgen"
 version = "0.1.0"
 dependencies = [
- "uniffi 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
  "workspace-hack",
 ]
 
@@ -11633,7 +11633,7 @@ dependencies = [
 [[package]]
 name = "uniffi_bindgen"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "askama",
@@ -11649,10 +11649,10 @@ dependencies = [
  "tempfile",
  "textwrap",
  "toml 1.1.6+spec-1.1.0",
- "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_udl 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_udl 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
@@ -11670,7 +11670,7 @@ dependencies = [
 [[package]]
 name = "uniffi_core"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "bytes",
@@ -11694,7 +11694,7 @@ dependencies = [
 [[package]]
 name = "uniffi_internal_macros"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "indexmap 2.14.2",
@@ -11723,7 +11723,7 @@ dependencies = [
 [[package]]
 name = "uniffi_macros"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "camino",
  "fs-err",
@@ -11733,7 +11733,7 @@ dependencies = [
  "serde",
  "syn 2.0.119",
  "toml 1.1.6+spec-1.1.0",
- "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
@@ -11751,12 +11751,12 @@ dependencies = [
 [[package]]
 name = "uniffi_meta"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "siphasher",
- "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "uniffi_pipeline 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
@@ -11775,13 +11775,13 @@ dependencies = [
 [[package]]
 name = "uniffi_pipeline"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "heck",
  "indexmap 2.14.2",
  "tempfile",
- "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_internal_macros 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
@@ -11799,12 +11799,12 @@ dependencies = [
 [[package]]
 name = "uniffi_udl"
 version = "0.32.2"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "anyhow",
  "textwrap",
- "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
- "weedle2 5.0.0 (git+https://github.com/kixelated/uniffi-rs?rev=88d835d)",
+ "uniffi_meta 0.32.2 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
+ "weedle2 5.0.0 (git+https://github.com/kixelated/uniffi-rs?rev=35209f3)",
 ]
 
 [[package]]
@@ -12358,7 +12358,7 @@ dependencies = [
 [[package]]
 name = "weedle2"
 version = "5.0.0"
-source = "git+https://github.com/kixelated/uniffi-rs?rev=88d835d#88d835d66abc6357b0bcd290b4c2adb35096cd10"
+source = "git+https://github.com/kixelated/uniffi-rs?rev=35209f3#35209f3f87051b940f68138fe685ed3ecfb02038"
 dependencies = [
  "nom 7.1.3",
 ]
diff --git a/dart/README.md b/dart/README.md
index 53dba2c52f8..a193fbb5089 100644
--- a/dart/README.md
+++ b/dart/README.md
@@ -23,14 +23,14 @@ WebAssembly. Browser applications should use the TypeScript packages.
 ## Generator
 
 Bindings use [`kixelated/uniffi-dart`](https://github.com/kixelated/uniffi-dart)
-tag `v0.3.1-kixelated.6+v0.32.0`, which carries the UniFFI 0.32,
-library-mode CLI, and disposed-argument changes. The Nix development shell supplies that exact
+tag `v0.3.1-kixelated.7+v0.32.0`, which carries the UniFFI 0.32, library-mode CLI,
+disposed-argument, and allocation-failure ownership changes. The Nix development shell supplies that exact
 revision plus the `nix/uniffi-dart-*.patch` fixes. Without Nix, install it
 without those fixes:
 
 ```bash
 cargo install --git https://github.com/kixelated/uniffi-dart \
-  --tag 'v0.3.1-kixelated.6+v0.32.0' --features binary uniffi-dart
+  --tag 'v0.3.1-kixelated.7+v0.32.0' --features binary uniffi-dart
 ```
 
 ## Releases
diff --git a/dart/moq_ffi/lib/src/moq.dart b/dart/moq_ffi/lib/src/moq.dart
index f1cddc8aa09..04866b2863b 100644
--- a/dart/moq_ffi/lib/src/moq.dart
+++ b/dart/moq_ffi/lib/src/moq.dart
@@ -8906,9 +8906,15 @@ class MoqAudioCodec implements MoqAudioCodecInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAudioCodecFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqaudiocodec(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqaudiocodec(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 }
 
@@ -8992,9 +8998,15 @@ class MoqAudioConsumer implements MoqAudioConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAudioConsumerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqaudioconsumer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqaudioconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -9101,9 +9113,15 @@ class MoqAudioEncoder implements MoqAudioEncoderInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAudioEncoderFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqaudioencoder(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqaudioencoder(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqAudioPacket encode({required List<double> pcm}) {
@@ -9236,9 +9254,15 @@ class MoqAudioProducer implements MoqAudioProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAudioProducerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqaudioproducer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqaudioproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqTrackDemand demand() {
@@ -9350,9 +9374,15 @@ class MoqGrantConsumer implements MoqGrantConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqGrantConsumerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqgrantconsumer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqgrantconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -9446,9 +9476,15 @@ class MoqAllocator implements MoqAllocatorInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAllocatorFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqallocator(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqallocator(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqReservation reserve({
@@ -9528,11 +9564,15 @@ class MoqBandwidthConsumer implements MoqBandwidthConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBandwidthConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbandwidthconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbandwidthconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -9627,9 +9667,15 @@ class MoqReservation implements MoqReservationInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqReservationFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqreservation(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqreservation(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   int? rate() {
@@ -9724,11 +9770,15 @@ class MoqBroadcastConsumer implements MoqBroadcastConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBroadcastConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbroadcastconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbroadcastconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   UniffiRustFuture<void> closed() {
@@ -9864,9 +9914,15 @@ class MoqGroupConsumer implements MoqGroupConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqGroupConsumerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqgroupconsumer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqgroupconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -9966,9 +10022,15 @@ class MoqTrackConsumer implements MoqTrackConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTrackConsumerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtrackconsumer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtrackconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -10116,9 +10178,15 @@ class MoqTrackDemand implements MoqTrackDemandInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTrackDemandFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtrackdemand(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtrackdemand(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   String name() {
@@ -10228,11 +10296,15 @@ class MoqJsonSnapshotConsumer implements MoqJsonSnapshotConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonSnapshotConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonsnapshotconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonsnapshotconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -10348,11 +10420,15 @@ class MoqJsonSnapshotProducer implements MoqJsonSnapshotProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonSnapshotProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonsnapshotproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonsnapshotproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqTrackDemand demand() {
@@ -10456,11 +10532,15 @@ class MoqJsonStreamConsumer implements MoqJsonStreamConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonStreamConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonstreamconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonstreamconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -10560,11 +10640,15 @@ class MoqJsonStreamProducer implements MoqJsonStreamProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonStreamProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonstreamproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonstreamproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void append({required String value, MoqTimestamp? timestamp = null}) {
@@ -10668,11 +10752,15 @@ class MoqJsonWindowConsumer implements MoqJsonWindowConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonWindowConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonwindowconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonwindowconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -10774,11 +10862,15 @@ class MoqJsonWindowProducer implements MoqJsonWindowProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqJsonWindowProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqjsonwindowproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqjsonwindowproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cut() {
@@ -10909,11 +11001,15 @@ class MoqMediaCatalogConsumer implements MoqMediaCatalogConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaCatalogConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqmediacatalogconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediacatalogconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -11012,11 +11108,15 @@ class MoqMediaCatalogProducer implements MoqMediaCatalogProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaCatalogProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqmediacatalogproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediacatalogproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void finish() {
@@ -11147,12 +11247,15 @@ class MoqMediaContainerProducer implements MoqMediaContainerProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaContainerProducerFinalizer.detach(this);
-    rustCall(
-      (status) =>
-          uniffi_moq_ffi_fn_free_moqmediacontainerproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediacontainerproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cut() {
@@ -11286,11 +11389,15 @@ class MoqMediaGroupConsumer implements MoqMediaGroupConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaGroupConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqmediagroupconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediagroupconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -11392,9 +11499,15 @@ class MoqMediaTimebase implements MoqMediaTimebaseInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaTimebaseFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqmediatimebase(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqmediatimebase(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 }
 
@@ -11476,11 +11589,15 @@ class MoqMediaTrackConsumer implements MoqMediaTrackConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaTrackConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqmediatrackconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediatrackconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -11600,11 +11717,15 @@ class MoqMediaTrackProducer implements MoqMediaTrackProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaTrackProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqmediatrackproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediatrackproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cut() {
@@ -11744,12 +11865,15 @@ class MoqMediaTrackStreamProducer
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqMediaTrackStreamProducerFinalizer.detach(this);
-    rustCall(
-      (status) =>
-          uniffi_moq_ffi_fn_free_moqmediatrackstreamproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqmediatrackstreamproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqTrackDemand demand() {
@@ -11840,11 +11964,15 @@ class MoqAnnounceConsumer implements MoqAnnounceConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqAnnounceConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqannounceconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqannounceconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -11930,11 +12058,15 @@ class MoqBroadcastPrepared implements MoqBroadcastPreparedInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBroadcastPreparedFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbroadcastprepared(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbroadcastprepared(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqBroadcastProducer broadcast() {
@@ -12018,11 +12150,15 @@ class MoqBroadcastRequest implements MoqBroadcastRequestInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBroadcastRequestFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbroadcastrequest(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbroadcastrequest(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   String path() {
@@ -12116,9 +12252,15 @@ class MoqFollowing implements MoqFollowingInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqFollowingFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqfollowing(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqfollowing(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   UniffiRustFuture<MoqBroadcastConsumer> available() {
@@ -12206,11 +12348,15 @@ class MoqOriginConsumer implements MoqOriginConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqOriginConsumerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqoriginconsumer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqoriginconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqAnnounceConsumer announced({required MoqAnnounceConfig config}) {
@@ -12327,11 +12473,15 @@ class MoqOriginProducer implements MoqOriginProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqOriginProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqoriginproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqoriginproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqOriginConsumer consume() {
@@ -12427,11 +12577,15 @@ class MoqOriginRequests implements MoqOriginRequestsInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqOriginRequestsFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqoriginrequests(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqoriginrequests(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -12517,9 +12671,15 @@ class MoqPublication implements MoqPublicationInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqPublicationFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqpublication(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqpublication(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void announce({required MoqAnnounceRoute route}) {
@@ -12625,11 +12785,15 @@ class MoqBroadcastProducer implements MoqBroadcastProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBroadcastProducerFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbroadcastproducer(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbroadcastproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void close() {
@@ -12739,11 +12903,15 @@ class MoqBroadcastRequests implements MoqBroadcastRequestsInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqBroadcastRequestsFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqbroadcastrequests(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqbroadcastrequests(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -12835,9 +13003,15 @@ class MoqFill implements MoqFillInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqFillFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqfill(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqfill(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqGroupProducer accept({required int sequence}) {
@@ -13037,9 +13211,15 @@ class MoqGroupProducer implements MoqGroupProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqGroupProducerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqgroupproducer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqgroupproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void abort({required int errorCode}) {
@@ -13161,9 +13341,15 @@ class MoqTrackProducer implements MoqTrackProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTrackProducerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtrackproducer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtrackproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void abort({required int errorCode}) {
@@ -13357,9 +13543,15 @@ class MoqTrackRequest implements MoqTrackRequestInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTrackRequestFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtrackrequest(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtrackrequest(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void abort({required int errorCode}) {
@@ -13475,9 +13667,15 @@ class MoqTrackRequests implements MoqTrackRequestsInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTrackRequestsFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtrackrequests(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtrackrequests(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -13570,9 +13768,15 @@ class MoqRequest implements MoqRequestInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqRequestFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqrequest(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqrequest(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   UniffiRustFuture<MoqSession> accept({
@@ -13738,9 +13942,15 @@ class MoqServer implements MoqServerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqServerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqserver(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqserver(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   UniffiRustFuture<MoqRequest?> accept() {
@@ -13852,9 +14062,15 @@ class MoqClient implements MoqClientInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqClientFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqclient(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqclient(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -13946,9 +14162,15 @@ class MoqSession implements MoqSessionInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqSessionFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqsession(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqsession(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   MoqAllocator allocator() {
@@ -14143,9 +14365,15 @@ class MoqTokens implements MoqTokensInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqTokensFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqtokens(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqtokens(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   UniffiRustFuture<void> answered() {
@@ -14250,9 +14478,15 @@ class MoqVideoConsumer implements MoqVideoConsumerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqVideoConsumerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqvideoconsumer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqvideoconsumer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cancel() {
@@ -14340,11 +14574,15 @@ class MoqVideoDecodedFrame implements MoqVideoDecodedFrameInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqVideoDecodedFrameFinalizer.detach(this);
-    rustCall(
-      (status) => uniffi_moq_ffi_fn_free_moqvideodecodedframe(_ptr, status),
-    );
+    try {
+      uniffi_moq_ffi_fn_free_moqvideodecodedframe(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   int height() {
@@ -14477,9 +14715,15 @@ class MoqVideoEncoder implements MoqVideoEncoderInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqVideoEncoderFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqvideoencoder(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqvideoencoder(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cut() {
@@ -14610,9 +14854,15 @@ class MoqVideoProducer implements MoqVideoProducerInterface {
     if (_isDisposed) {
       return;
     }
+    final status = calloc<RustCallStatus>();
     _isDisposed = true;
     _MoqVideoProducerFinalizer.detach(this);
-    rustCall((status) => uniffi_moq_ffi_fn_free_moqvideoproducer(_ptr, status));
+    try {
+      uniffi_moq_ffi_fn_free_moqvideoproducer(_ptr, status);
+      checkCallStatus(NullRustCallStatusErrorHandler(), status);
+    } finally {
+      calloc.free(status);
+    }
   }
 
   void cut() {
diff --git a/dart/moq_ffi/lib/src/uniffi_runtime.dart b/dart/moq_ffi/lib/src/uniffi_runtime.dart
index c61178325f7..3b7dd9cf392 100644
--- a/dart/moq_ffi/lib/src/uniffi_runtime.dart
+++ b/dart/moq_ffi/lib/src/uniffi_runtime.dart
@@ -181,17 +181,19 @@ final class RustBuffer extends Struct {
 
 RustBuffer toRustBuffer(Uint8List data) {
   final length = data.length;
-  final Pointer<Uint8> frameData = calloc<Uint8>(length);
-  final pointerList = frameData.asTypedList(length);
-  pointerList.setAll(0, data);
-  final bytes = calloc<ForeignBytes>();
-  bytes.ref.len = length;
-  bytes.ref.data = frameData;
+  final frameData = calloc<Uint8>(length);
   try {
-    return RustBuffer.fromBytes(bytes.ref);
+    frameData.asTypedList(length).setAll(0, data);
+    final bytes = calloc<ForeignBytes>();
+    try {
+      bytes.ref.len = length;
+      bytes.ref.data = frameData;
+      return RustBuffer.fromBytes(bytes.ref);
+    } finally {
+      calloc.free(bytes);
+    }
   } finally {
     calloc.free(frameData);
-    calloc.free(bytes);
   }
 }
 
diff --git a/flake.nix b/flake.nix
index 52435b21ea8..31a5dfb888a 100644
--- a/flake.nix
+++ b/flake.nix
@@ -382,13 +382,13 @@
         # `-kixelated.N` pre-release so they never collide with upstream's.
         uniffi-bindgen-dart = pkgs.rustPlatform.buildRustPackage rec {
           pname = "uniffi-bindgen-dart";
-          version = "0.3.1-kixelated.6+v0.32.0";
+          version = "0.3.1-kixelated.7+v0.32.0";
 
           src = pkgs.fetchFromGitHub {
             owner = "kixelated";
             repo = "uniffi-dart";
             rev = "v${version}";
-            hash = "sha256-Ff5o3n4l1O578gJ5pInAqf6/MkM+lkwzovJtEffvpqk=";
+            hash = "sha256-uSApyCocEhADWu8Koj5vXIt0fMYQVjnBVKctDWQHqLM=";
           };
 
           # The upstream repository ignores Cargo.lock so cargo installs test
diff --git a/nix/uniffi-dart-Cargo.lock b/nix/uniffi-dart-Cargo.lock
index 2ac246974fd..3addd398bc3 100644
--- a/nix/uniffi-dart-Cargo.lock
+++ b/nix/uniffi-dart-Cargo.lock
@@ -1009,6 +1009,15 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "input_scratch"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "uniffi",
+ "uniffi-dart",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.13"
diff --git a/quest/m1/vendor-sync/uniffi.md b/quest/m1/vendor-sync/uniffi.md
index 30dfebb7ff4..d62a2185337 100644
--- a/quest/m1/vendor-sync/uniffi.md
+++ b/quest/m1/vendor-sync/uniffi.md
@@ -27,36 +27,45 @@ A port means a commit on the fork and a pin bump in moq (`flake.nix` and the
 places its "five places" comments name), with regenerated bindings diffed and
 each wrapper's check run.
 
-Last checked (2026-10-30), with each fork's base and pin:
-
-| Fork | Base | Pin | Upstream head | Behind |
-|---|---|---|---|---|
-| uniffi-rs | `v0.32.2` (`7bc621ee`) | `88d835d6` | `ef9625b6` | 105 on `main`, no newer release |
-| uniffi-bindgen-go | `0b7fb4ce` | `v0.10.0-kixelated.1+v0.32.0` | `0b7fb4ce` | 0 |
-| uniffi-dart | `72d26c1f` | `v0.3.1-kixelated.6+v0.32.0` | `34f57ea7` | 26 |
-| uniffi-bindgen-cpp | `20bef754` | `v0.11.0-kixelated.7+v0.32.2` | `20bef754` | 0 |
-
-First run, check these first:
-
-- uniffi-dart [`71dc9f8b`](https://github.com/Uniffi-Dart/uniffi-dart/commit/71dc9f8b)
-  frees native scratch after an owned input conversion, a leak in every Dart
-  call that takes one. Upstream also merged the library-mode CLI and the enum
-  collision fix the fork carries, so rebasing the fork onto upstream may
-  shrink it; also check `019f3192` (custom types lowered to their builtin in
-  FFI signatures) and `a316d101` (`$` escaped in string defaults).
-- uniffi-rs `main`, unreleased: [`2ccd07e2`](https://github.com/mozilla/uniffi-rs/commit/2ccd07e2)
-  (Kotlin checksum compares the right u16),
-  [`d1f766f4`](https://github.com/mozilla/uniffi-rs/commit/d1f766f4) (Kotlin
-  Throwable handling), and [`f903c36c`](https://github.com/mozilla/uniffi-rs/commit/f903c36c)
-  (Python prefers the running event loop).
-
-Fork CI, added 2026-11-01 (maintainer, follow-up planning after the
-2026-11-01 /quest-afk run): kixelated/uniffi-dart's `Testing`
+Last checked (2026-10-31), with each fork's base and pin:
+
+| Fork | Base | Pin | Upstream head checked |
+|---|---|---|---|
+| uniffi-rs | `v0.32.2` (`7bc621ee`) | `35209f3f` | [`ef9625b6`](https://github.com/mozilla/uniffi-rs/commit/ef9625b68dd51207f55f024a27649e58edb52b09) |
+| uniffi-bindgen-go | `0b7fb4ce` | `v0.10.0-kixelated.1+v0.32.0` | [`0b7fb4ce`](https://github.com/NordSecurity/uniffi-bindgen-go/commit/0b7fb4ceef12021bd7f790cc516fa9133e001813) |
+| uniffi-dart | `72d26c1f` | `v0.3.1-kixelated.7+v0.32.0` (`657cbff5`) | [`e644a4ad`](https://github.com/Uniffi-Dart/uniffi-dart/commit/e644a4ad980f72697aba211fd30cb4fbd8fc7324) |
+| uniffi-bindgen-cpp | `20bef754` | `v0.11.0-kixelated.7+v0.32.2` | [`20bef754`](https://github.com/livekit/uniffi-bindgen-cpp/commit/20bef754391023df147267482513c35120dee343) |
+
+That run ([moq-dev/moq#7461](https://github.com/moq-dev/moq/pull/7461))
+ported Python's running-loop preference (`f903c36c`) in
+[kixelated/uniffi-rs#1](https://github.com/kixelated/uniffi-rs/pull/1), and
+Dart's nested input-scratch cleanup (`71dc9f8b`) and disposal status
+reservation (`a2751c4c`) in
+[kixelated/uniffi-dart#7](https://github.com/kixelated/uniffi-dart/pull/7).
+Both landed on `moq-0.32` as merge commits, so the pinned heads stay
+reachable. [moq-dev/rust2#364](https://github.com/moq-dev/rust2/pull/364)
+mirrors both into rust2's fork. No upstream published a security advisory;
+Go and C++ had no new upstream commits; Kotlin's checksum mask was already in
+the pin (`2a8331b7`).
+
+Ruled out, so the next run can skip them unless MoQ starts using the feature:
+MoQ exports no foreign-implementable traits, custom types, dollar-bearing
+defaults, or recursive enum graphs, so Kotlin Throwable handling, Swift async
+callback concurrency, Dart incoming callback buffers, custom FFI lowering,
+string-default escaping, and recursive/custom-type fixes have no generated
+MoQ consumer. Upstream main's parser, JNI backend, mutable bytes, and
+library-mode removal are a redesign, not a port.
+
+Remaining: fork CI, added 2026-11-01 (maintainer, follow-up planning after the
+2026-11-01 /quest-afk run). kixelated/uniffi-dart's `Testing`
 (`.github/workflows/tests.yml`) and `Test Downstream`
-(`.github/workflows/test-downstream.yml`) workflows failed in all 14 of their
-runs among the fork's 30 most recent PR runs that day, while `Nix` passed, so
-a red check on a fork PR, including a vendor sync's own, says nothing. In `Testing`, `Test Suite (stable)`
-failed at `Run cargo nextest` while nightly passed and 1.91 was cancelled.
-Fix them, or drop them where the fork's `Nix` job and moq's own binding
-checks already cover what they test, and record which in the fork's README.
-Keep the fork's CI read-only, as `quest guide`'s Reviews section requires.
+(`.github/workflows/test-downstream.yml`) workflows fail on every fork PR
+while `Nix` passes, so a red check on a fork PR, including a vendor sync's
+own, says nothing. On kixelated/uniffi-dart#7, `Test Suite (stable)` and
+`(1.91)` failed while nightly passed; stable's failure is
+`fixtures/dart_async/test/futures_test.dart`'s `sleep`, which expects strictly
+more than 200 ms from a 200 ms sleep. `Test bdk-dart Bindings` fails because
+bdk-dart's `native/Cargo.lock` needs updating under `--locked`. Fix them,
+or drop them where the fork's `Nix` job and moq's own binding checks already
+cover what they test, and record which in the fork's README. Keep the fork's
+CI read-only, as `quest guide`'s Reviews section requires.
diff --git a/rs/uniffi-bindgen/Cargo.toml b/rs/uniffi-bindgen/Cargo.toml
index f4c43377d56..fc89aee83dc 100644
--- a/rs/uniffi-bindgen/Cargo.toml
+++ b/rs/uniffi-bindgen/Cargo.toml
@@ -21,7 +21,7 @@ cli = ["dep:uniffi"]
 [dependencies]
 # Generator-only fork of UniFFI 0.32.2. moq-ffi stays on crates.io so its
 # published package has no git dependencies.
-uniffi = { git = "https://github.com/kixelated/uniffi-rs", rev = "88d835d", features = ["cli"], optional = true }
+uniffi = { git = "https://github.com/kixelated/uniffi-rs", rev = "35209f3", features = ["cli"], optional = true }
 
 [dev-dependencies]
 workspace-hack = { path = "../workspace-hack" }
diff --git a/sh/dispatch-query.test.py b/sh/dispatch-query.test.py
index 5fbfbb1a193..f21b591e0f4 100644
--- a/sh/dispatch-query.test.py
+++ b/sh/dispatch-query.test.py
@@ -106,6 +106,13 @@ def test_cargo_configuration_selects_rust(self):
                 self.assertTrue(any(call.startswith("rs test-changed ") for call in calls), calls)
                 (self.repo / path).unlink()
 
+    def test_generator_pin_checks_the_bindings_it_renders(self):
+        self.change("rs/uniffi-bindgen/Cargo.toml")
+        calls = self.run_ci()
+        for module in ("py", "kt", "swift"):
+            self.assertIn(f"{module} check", calls)
+        self.assertNotIn("go check", calls)
+
     def test_nixpkgs_updates_check_browser_pins(self):
         self.change("flake.lock")
         self.expect(True)
diff --git a/sh/dispatch.sh b/sh/dispatch.sh
index 2a4a4e3f461..36ef805572c 100755
--- a/sh/dispatch.sh
+++ b/sh/dispatch.sh
@@ -100,14 +100,15 @@ module() {
 
 # maturin bundles rs/moq-ffi into the moq-ffi wheel, and the other bindings
 # generate from it, built by the `cargo build-ffi` alias in .cargo/config.toml.
-# Each binding's check also compiles its doc samples. kt, swift, go, cpp, and
+# Each binding's check also compiles its doc samples. Python, Kotlin, and Swift
+# render through the rs/uniffi-bindgen generator fork. kt, swift, go, cpp, and
 # obs_compile each build moq-ffi's cdylib with the same features and profile
 # before reading target/debug/libmoq_ffi.so. Cargo runs one build at a time per
 # target directory and leaves a fresh output untouched, so the first of those
 # lanes builds it while the rest wait in Cargo, and none rewrites it while
 # another reads it. py builds its test features into a target directory of its
 # own, and carla runs its tools outside py's venv.
-module py '^(py/|sh/py/|pyproject\.toml$|uv\.lock$|rs/moq-ffi/|doc/lib/py/|doc/lib/samples\.sh$)' \
+module py '^(py/|sh/py/|pyproject\.toml$|uv\.lock$|rs/moq-ffi/|rs/uniffi-bindgen/|doc/lib/py/|doc/lib/samples\.sh$)' \
     tools='uv' compiles=check
 # sh/rs/select.sh widens to the whole workspace for inputs every crate shares.
 # moq-cli builds the Rust interop clients as examples from outside its
@@ -137,7 +138,7 @@ module obs_compile '^(\.cargo/config\.toml$|cpp/obs/|cpp/moq/|sh/obs/|rs/moq-ffi
 # them fails.
 module js '^(js/|bench/browser/|doc/|drafts/|demo/(boy|pub|web|carla/web)/|test/|rs/.*\.json$|sh/js/|sh/rs/stats-docs\.py$|package\.json$|bun\.lock(b)?$|biome\.jsonc$|flake\.(nix|lock)$)' \
     tools='bun python3' lane=bun fix
-module kt '^(\.cargo/config\.toml$|kt/|sh/kt/|rs/moq-ffi/|doc/lib/kt/|doc/lib/samples\.sh$)' \
+module kt '^(\.cargo/config\.toml$|kt/|sh/kt/|rs/moq-ffi/|rs/uniffi-bindgen/|doc/lib/kt/|doc/lib/samples\.sh$)' \
     tools='cargo gradle java ktfmt' compiles=check fix
 # Rust source is compiled below. Nix reads Cargo metadata, packaging inputs,
 # and its own modules and test helpers; those still gate the full flake.
@@ -152,7 +153,7 @@ module carla '^demo/carla/(sim/|justfile$)' \
 # swift needs no tools: it skips off macOS by design, and platform.yml is its
 # real gate. Its formatter is absent where nixpkgs cannot build it (see
 # flake.nix).
-module swift '^(\.cargo/config\.toml$|swift/|sh/swift/|rs/moq-ffi/|doc/lib/swift/|doc/lib/samples\.sh$)' \
+module swift '^(\.cargo/config\.toml$|swift/|sh/swift/|rs/moq-ffi/|rs/uniffi-bindgen/|doc/lib/swift/|doc/lib/samples\.sh$)' \
     fix
 module go '^(\.cargo/config\.toml$|go/|sh/go/|rs/moq-ffi/|doc/lib/go/|doc/lib/samples\.sh$)' \
     tools='cargo go uniffi-bindgen-go' compiles=check fix