@githolon/dsl 0.113.4 → 0.115.0

package/dart/lib/src/testing/test_peer.dart

@@ -10,9 +10,9 @@ import 'package:fixnum/fixnum.dart' show Int64;
 import 'package:meta/meta.dart' show internal;
 import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
 
-import '../node_runner_transport.dart';
 import '../reception/dart_reception.dart';
-import 'test_custody.dart';
+import '../reception/peer_office_connection.dart';
+import 'test_peer_host.dart';
 
 @internal
 final class NmsInstalledTestWorkspace {
@@ -31,78 +31,88 @@ final class NmsInstalledTestWorkspace {
   final Set<String> domainKeys;
 }
 
-/// A canonical Peer Office hosted by the Node test Platform Shell.
+/// A canonical Peer Office hosted by one test Platform Shell ([NmsTestPeerHost]).
 ///
 /// This class owns fixture setup only. Every operation crosses Runtime v2 and
 /// the kernel's generated Protobuf ABI; it contains no workspace lifecycle,
-/// USDA parser, generic payload map or alternate admission path.
+/// USDA parser, generic payload map or alternate admission path. The host is the
+/// Node shell by default and the Apple native host when `NOMOS_TEST_PEER_HOST=native`.
 @internal
 final class NmsTestPeer {
   NmsTestPeer._({
-    required this.transport,
+    required this.host,
     required this.reception,
-    required this.custody,
     required this.runtimeDirectory,
-    required String entry,
-    required String node,
-    String? resolveFrom,
-    void Function(String line)? onDiagnostic,
-  })  : _entry = entry,
-        _node = node,
-        _resolveFrom = resolveFrom,
-        _onDiagnostic = onDiagnostic;
+  });
+
+  /// The platform host this peer stands on.
+  final NmsTestPeerHost host;
 
-  /// The live process transport; replaced by [reboot].
-  NodeRunnerTransport transport;
+  /// The live Peer Office connection; replaced when the host restarts.
+  PeerOfficeConnection get transport => host.connection;
 
-  /// Reception over [transport]; replaced by [reboot].
+  /// Reception over [transport]; replaced by [reboot] and [trustFoundingRoot].
   DartReception reception;
-  final NmsTestCustody custody;
+
+  /// The temporary directory holding this peer's Git custody.
+  Directory get custodyDirectory => host.custodyDirectory;
   final String runtimeDirectory;
-  final String _entry;
-  final String _node;
-  final String? _resolveFrom;
-  final void Function(String line)? _onDiagnostic;
   final Random _random = Random.secure();
   int _requestSequence = 0;
   int _authoringSequence = 0;
 
-  static Future<NmsTestPeer> start({
-    required String entry,
+  /// Open a canonical test peer on an already started [host]. The peer owns the host from
+  /// here on: a failure disposes it.
+  static Future<NmsTestPeer> open({
+    required NmsTestPeerHost host,
     required String runtimeDirectory,
-    String node = 'node',
-    String? resolveFrom,
-    void Function(String line)? onDiagnostic,
   }) async {
-    final custody = await NmsTestCustody.create();
-    NodeRunnerTransport? transport;
     try {
-      transport = await NodeRunnerTransport.start(
-        entry: entry,
-        resolveFrom: resolveFrom,
-        node: node,
-        arguments: custody.processArguments(runtimeDirectory),
-        onDiagnostic: onDiagnostic,
-      );
-      final reception = DartReception(transport);
-      await reception.ready;
+      final reception = DartReception(host.connection);
+      await host.awaitReady(reception);
       return NmsTestPeer._(
-        transport: transport,
+        host: host,
         reception: reception,
-        custody: custody,
         runtimeDirectory: runtimeDirectory,
-        entry: entry,
-        node: node,
-        resolveFrom: resolveFrom,
-        onDiagnostic: onDiagnostic,
       );
     } catch (_) {
-      await transport?.dispose();
-      await custody.dispose();
+      await host.dispose();
       rethrow;
     }
   }
 
+  /// Start a test peer on the host [kind]: the Node shell at [entry] (required exactly for
+  /// Node), or the registered Apple native host.
+  static Future<NmsTestPeer> start({
+    required NmsTestPeerHostKind kind,
+    required String runtimeDirectory,
+    String? entry,
+    String node = 'node',
+    String? resolveFrom,
+    void Function(String line)? onDiagnostic,
+  }) async {
+    final request = NmsTestPeerHostRequest(
+      runtimeDirectory: runtimeDirectory,
+      onDiagnostic: onDiagnostic,
+    );
+    final NmsTestPeerHost host;
+    switch (kind) {
+      case NmsTestPeerHostKind.node:
+        if (entry == null) {
+          throw ArgumentError.notNull('entry');
+        }
+        host = await NmsNodeTestPeerHost.start(
+          entry: entry,
+          request: request,
+          node: node,
+          resolveFrom: resolveFrom,
+        );
+      case NmsTestPeerHostKind.native:
+        host = await NmsTestPeerHosts.requireNative()(request);
+    }
+    return open(host: host, runtimeDirectory: runtimeDirectory);
+  }
+
   protocol.AuthoringOptions _authoring(String actor) {
     _authoringSequence += 1;
     return protocol.AuthoringOptions(
@@ -123,7 +133,7 @@ final class NmsTestPeer {
     String session,
     protocol.CallRequest request,
   ) async {
-    final response = await transport.callKernel(
+    final response = await host.kernelCalls.callKernel(
       session: session,
       request: request,
       credentialUse: protocol.CredentialUse.CREDENTIAL_USE_NONE,
@@ -138,31 +148,15 @@ final class NmsTestPeer {
     Uint8List bytes,
     String label,
   ) async {
-    final id = Int64(++_requestSequence);
-    final response = await transport.invokeRuntime(
-      protocol.RuntimeRequest(
-        protocolVersion: 2,
-        requestId: id,
-        inspectLawPackage: protocol.InspectLawPackageRequest(
-          lawUsdz: bytes,
-          label: label,
-        ),
-      ),
-    );
-    if (response.hasFailure()) {
-      throw StateError('${response.failure.code}: ${response.failure.message}');
-    }
-    if (!response.hasLawPackageInspection() ||
-        response.lawPackageInspection.identity.isEmpty) {
-      throw StateError(
-        'Peer Office returned ${response.whichOutcome().name} while inspecting $label',
-      );
+    final inspection = await host.inspectLawPackage(bytes, label);
+    if (inspection.identity.isEmpty) {
+      throw StateError('the kernel named no identity for $label');
     }
-    return response.lawPackageInspection;
+    return inspection;
   }
 
   /// Mint a founding device key on a scratch session BEFORE any custody exists, so the peer can be
-  /// booted to trust it (typed boot configuration) ahead of the genesis it will sign.
+  /// made to trust it (typed boot configuration) ahead of the genesis it will sign.
   Future<protocol.SigningKeyPair> mintFoundingDevice() async {
     final scratch = 'nms-founder-${_random.nextInt(1 << 30).toRadixString(36)}';
     await reception.bindSession(
@@ -182,7 +176,7 @@ final class NmsTestPeer {
       throw ArgumentError.value(
           lawUsdzPaths, 'lawUsdzPaths', 'must not be empty');
     }
-    await custody.provisionWorkspace(workspace);
+    await host.provisionWorkspace(workspace);
     await reception.bindSession(
       workspace: workspace,
       session: workspace,
@@ -270,38 +264,37 @@ final class NmsTestPeer {
     );
   }
 
-  /// Reboot the peer process on the SAME Git custody with [trustRootPublicKey] as its typed
-  /// boot configuration, then reopen every workspace this peer installed. The trust root is boot
-  /// configuration of the shell, never a kernel variant: a ceremony that signs with a founding
-  /// device key first boots the peer to trust that key.
+  /// Trust [trustRootPublicKey] as this peer's universe root before the genesis it will sign.
+  /// The trust root is boot configuration of the shell, never a kernel variant: the Node host
+  /// reboots its process with it; the native host configures its resident kernel once.
+  Future<void> trustFoundingRoot(List<int> trustRootPublicKey) async {
+    _requireRootKey(trustRootPublicKey);
+    final replaced = await host.trustFoundingRoot(
+      trustRootPublicKey,
+      beforeReplacingConnection: reception.dispose,
+    );
+    if (!replaced) return;
+    final reopened = DartReception(host.connection);
+    await host.awaitReady(reopened);
+    reception = reopened;
+  }
+
+  /// Reboot the peer on the SAME Git custody with [trustRootPublicKey] as its typed boot
+  /// configuration, then reopen every workspace named in [authorSecrets]. A host that cannot
+  /// restart in-process (native: its resident kernel is process-wide) refuses loudly.
   Future<void> reboot({
     required List<int> trustRootPublicKey,
     Map<String, String> authorSecrets = const {},
     Future<void> Function()? arrangeStoppedCustody,
   }) async {
-    if (trustRootPublicKey.length != 32) {
-      throw ArgumentError.value(
-        trustRootPublicKey.length,
-        'trustRootPublicKey',
-        'must be a 32-byte public key',
-      );
-    }
+    _requireRootKey(trustRootPublicKey);
     await reception.dispose();
-    await transport.dispose();
-    await arrangeStoppedCustody?.call();
-    final restarted = await NodeRunnerTransport.start(
-      entry: _entry,
-      resolveFrom: _resolveFrom,
-      node: _node,
-      arguments: custody.processArguments(
-        runtimeDirectory,
-        trustRootPublicKey: base64Encode(trustRootPublicKey),
-      ),
-      onDiagnostic: _onDiagnostic,
+    await host.restart(
+      trustRootPublicKey: trustRootPublicKey,
+      arrangeStoppedCustody: arrangeStoppedCustody,
     );
-    final reopened = DartReception(restarted);
-    await reopened.ready;
-    transport = restarted;
+    final reopened = DartReception(host.connection);
+    await host.awaitReady(reopened);
     reception = reopened;
     for (final entry in authorSecrets.entries) {
       await reception.bindSession(
@@ -314,15 +307,30 @@ final class NmsTestPeer {
     }
   }
 
+  void _requireRootKey(List<int> trustRootPublicKey) {
+    if (trustRootPublicKey.length != 32) {
+      throw ArgumentError.value(
+        trustRootPublicKey.length,
+        'trustRootPublicKey',
+        'must be a 32-byte public key',
+      );
+    }
+  }
+
+  /// Close Reception and stop the host's connection; custody stays on disk.
+  Future<void> stop() async {
+    try {
+      await reception.dispose();
+    } finally {
+      await host.stop();
+    }
+  }
+
   Future<void> dispose() async {
     try {
       await reception.dispose();
     } finally {
-      try {
-        await transport.dispose();
-      } finally {
-        await custody.dispose();
-      }
+      await host.dispose();
     }
   }
 }

package/dart/lib/src/testing/test_peer_host.dart

@@ -0,0 +1,305 @@
+@internal
+library;
+
+import 'dart:convert' show base64Encode;
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:fixnum/fixnum.dart' show Int64;
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
+
+import '../node_runner_transport.dart';
+import '../reception/dart_reception.dart' show DartReception;
+import '../reception/peer_office_connection.dart';
+import '../runtime_v2_transport.dart' show NomosKernelCallTransport;
+import 'test_custody.dart';
+
+/// The environment variable that selects the platform host of the canonical test peer.
+///
+/// Unset (or `node`) is the default fast iteration loop: the Node Platform Shell over the
+/// WASM kernel. `native` selects the Apple native host (the release-linked AOT kernel and the
+/// Peer Office in JavaScriptCore) for production-equivalent figures on a Mac; it must have been
+/// registered by the caller (see [NmsTestPeerHosts.registerNative]). Any other value is refused.
+const nmsTestPeerHostVariable = 'NOMOS_TEST_PEER_HOST';
+
+/// Which platform shell hosts the test peer.
+enum NmsTestPeerHostKind {
+  node,
+  native;
+
+  /// The host selected by [nmsTestPeerHostVariable]. A value that names no host is refused —
+  /// a typo never silently becomes the default Node lane.
+  static NmsTestPeerHostKind selected([Map<String, String>? environment]) {
+    final raw = (environment ?? Platform.environment)[nmsTestPeerHostVariable];
+    final value = raw?.trim() ?? '';
+    switch (value) {
+      case '':
+      case 'node':
+        return NmsTestPeerHostKind.node;
+      case 'native':
+        return NmsTestPeerHostKind.native;
+      default:
+        throw StateError(
+          '$nmsTestPeerHostVariable="$raw" names no test peer host: '
+          'leave it unset (or "node") for the Node peer, or set "native" for the Apple native host',
+        );
+    }
+  }
+}
+
+/// What a host needs to open one canonical test peer.
+final class NmsTestPeerHostRequest {
+  const NmsTestPeerHostRequest({
+    required this.runtimeDirectory,
+    this.onDiagnostic,
+  });
+
+  /// The runtime bundle directory. Every host reads the framework controller
+  /// `nomos.law.usdz` from it for the constitutional genesis offer; only the Node host
+  /// executes its `holon.wasm`.
+  final String runtimeDirectory;
+  final void Function(String line)? onDiagnostic;
+}
+
+/// One platform host of a canonical test Peer Office: the physical boundary the harness
+/// stands on. It owns process/library lifetime and the custody directory LAYOUT; it owns no
+/// workspace lifecycle, admission or law. Every operation the harness performs still crosses
+/// Runtime v2 through [connection].
+abstract interface class NmsTestPeerHost {
+  NmsTestPeerHostKind get kind;
+
+  /// The live Peer Office connection. A host whose trust-root application replaces the
+  /// connection (Node reboots its process) answers the new one afterwards.
+  PeerOfficeConnection get connection;
+
+  /// The generated binary kernel lane of [connection] (fixture genesis and law installs).
+  NomosKernelCallTransport get kernelCalls;
+
+  /// The temporary directory holding this peer's Git custody. Deleted by [dispose].
+  Directory get custodyDirectory;
+
+  /// The bare Git directory of [workspace] in this host's custody layout.
+  String workspaceGitDirectory(String workspace);
+
+  /// Provision the platform-owned empty custody into which the one parentless genesis
+  /// offer for [workspace] may write, in this host's layout. Fixture plumbing, not an
+  /// application lifecycle operation.
+  Future<void> provisionWorkspace(String workspace);
+
+  /// The kernel's inspection of an opaque law package: its content identity and domain keys.
+  /// Node asks its Peer Office (Runtime v2 `inspectLawPackage`). The Apple host's office has no
+  /// inspection port, so the native shell asks its resident kernel directly — the same
+  /// `custody.lawClosureInfo` call the Node adapter makes for its office.
+  Future<protocol.LawPackageInspection> inspectLawPackage(
+    Uint8List lawUsdz,
+    String label,
+  );
+
+  /// Complete once [reception] (a new Reception over [connection]) may be used: the Node shell
+  /// posts a `ready` event when its process has booted; the native host booted its resident
+  /// kernel and Peer Office when it started and posts no such event.
+  Future<void> awaitReady(DartReception reception);
+
+  /// Trust [publicKey] as the root of this peer's universe before the genesis it will sign.
+  /// Typed boot configuration, never a kernel variant. Node reboots its process with
+  /// `--trust-root-public-key` (calling [beforeReplacingConnection] first, and answering true:
+  /// the connection was replaced); native issues the kernel's one-time `configure` call on the
+  /// live connection and answers false.
+  Future<bool> trustFoundingRoot(
+    List<int> publicKey, {
+    required Future<void> Function() beforeReplacingConnection,
+  });
+
+  /// Restart the peer over the SAME custody with [trustRootPublicKey]. A host that cannot
+  /// restart in-process refuses loudly; it never pretends to have restarted.
+  Future<void> restart({
+    required List<int> trustRootPublicKey,
+    Future<void> Function()? arrangeStoppedCustody,
+  });
+
+  /// Stop the host's connection (and process, where it owns one). Custody stays on disk.
+  Future<void> stop();
+
+  /// [stop], then delete [custodyDirectory].
+  Future<void> dispose();
+}
+
+typedef NmsTestPeerHostFactory = Future<NmsTestPeerHost> Function(
+  NmsTestPeerHostRequest request,
+);
+
+/// The registry the harness selects a host from. nomos_client cannot depend on the Flutter
+/// shell, so the native host is injected by the caller (`nomos_flutter/testing.dart`).
+abstract final class NmsTestPeerHosts {
+  static NmsTestPeerHostFactory? _native;
+
+  /// Register the Apple native host. Registering does not select it: selection is
+  /// [nmsTestPeerHostVariable]=native.
+  static void registerNative(NmsTestPeerHostFactory factory) {
+    _native = factory;
+  }
+
+  /// The registered native host factory. Selected-but-unregistered is a loud refusal with
+  /// the exact remedy, never a quiet fall back to Node.
+  static NmsTestPeerHostFactory requireNative() {
+    final factory = _native;
+    if (factory == null) {
+      throw StateError(
+        '$nmsTestPeerHostVariable=native selects the Apple native test peer host, but none is '
+        'registered in this process. Generated business scenarios register it themselves; a '
+        'raw harness in a macOS `flutter test` imports '
+        "'package:nomos_flutter/testing.dart' and calls registerNomosNativeTestPeerHost() "
+        '(e.g. in setUpAll) before opening a NomosTestHarness. Unset $nmsTestPeerHostVariable '
+        'to run on the default Node peer.',
+      );
+    }
+    return factory;
+  }
+}
+
+/// The default host: the Node test Platform Shell over the WASM kernel, custody laid out as
+/// `<root>/custody/holon-<ws>.git`.
+final class NmsNodeTestPeerHost implements NmsTestPeerHost {
+  NmsNodeTestPeerHost._({
+    required NodeRunnerTransport transport,
+    required this.custody,
+    required this.runtimeDirectory,
+    required String entry,
+    required String node,
+    required String? resolveFrom,
+    required void Function(String line)? onDiagnostic,
+  })  : _transport = transport,
+        _entry = entry,
+        _node = node,
+        _resolveFrom = resolveFrom,
+        _onDiagnostic = onDiagnostic;
+
+  NodeRunnerTransport _transport;
+  final NmsTestCustody custody;
+  final String runtimeDirectory;
+  final String _entry;
+  final String _node;
+  final String? _resolveFrom;
+  final void Function(String line)? _onDiagnostic;
+
+  static Future<NmsNodeTestPeerHost> start({
+    required String entry,
+    required NmsTestPeerHostRequest request,
+    String node = 'node',
+    String? resolveFrom,
+  }) async {
+    final custody = await NmsTestCustody.create();
+    try {
+      final transport = await NodeRunnerTransport.start(
+        entry: entry,
+        resolveFrom: resolveFrom,
+        node: node,
+        arguments: custody.processArguments(request.runtimeDirectory),
+        onDiagnostic: request.onDiagnostic,
+      );
+      return NmsNodeTestPeerHost._(
+        transport: transport,
+        custody: custody,
+        runtimeDirectory: request.runtimeDirectory,
+        entry: entry,
+        node: node,
+        resolveFrom: resolveFrom,
+        onDiagnostic: request.onDiagnostic,
+      );
+    } catch (_) {
+      await custody.dispose();
+      rethrow;
+    }
+  }
+
+  @override
+  NmsTestPeerHostKind get kind => NmsTestPeerHostKind.node;
+
+  @override
+  PeerOfficeConnection get connection => _transport;
+
+  @override
+  NomosKernelCallTransport get kernelCalls => _transport;
+
+  @override
+  Directory get custodyDirectory => custody.directory;
+
+  @override
+  String workspaceGitDirectory(String workspace) =>
+      '${custody.directory.path}/custody/holon-$workspace.git';
+
+  @override
+  Future<void> provisionWorkspace(String workspace) =>
+      custody.provisionWorkspace(workspace);
+
+  @override
+  Future<void> awaitReady(DartReception reception) => reception.ready;
+
+  @override
+  Future<protocol.LawPackageInspection> inspectLawPackage(
+    Uint8List lawUsdz,
+    String label,
+  ) async {
+    final response = await _transport.invokeRuntime(
+      protocol.RuntimeRequest(
+        protocolVersion: 2,
+        requestId: Int64(_transport.nextRuntimeRequestId()),
+        inspectLawPackage: protocol.InspectLawPackageRequest(
+          lawUsdz: lawUsdz,
+          label: label,
+        ),
+      ),
+    );
+    if (response.hasFailure()) {
+      throw StateError('${response.failure.code}: ${response.failure.message}');
+    }
+    if (!response.hasLawPackageInspection()) {
+      throw StateError(
+        'Peer Office returned ${response.whichOutcome().name} while inspecting $label',
+      );
+    }
+    return response.lawPackageInspection;
+  }
+
+  @override
+  Future<bool> trustFoundingRoot(
+    List<int> publicKey, {
+    required Future<void> Function() beforeReplacingConnection,
+  }) async {
+    await beforeReplacingConnection();
+    await restart(trustRootPublicKey: publicKey);
+    return true;
+  }
+
+  @override
+  Future<void> restart({
+    required List<int> trustRootPublicKey,
+    Future<void> Function()? arrangeStoppedCustody,
+  }) async {
+    await _transport.dispose();
+    await arrangeStoppedCustody?.call();
+    _transport = await NodeRunnerTransport.start(
+      entry: _entry,
+      resolveFrom: _resolveFrom,
+      node: _node,
+      arguments: custody.processArguments(
+        runtimeDirectory,
+        trustRootPublicKey: base64Encode(trustRootPublicKey),
+      ),
+      onDiagnostic: _onDiagnostic,
+    );
+  }
+
+  @override
+  Future<void> stop() => _transport.dispose();
+
+  @override
+  Future<void> dispose() async {
+    try {
+      await stop();
+    } finally {
+      await custody.dispose();
+    }
+  }
+}

package/dart/lib/src/typed_watch_registry.dart

@@ -4,6 +4,7 @@ import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
 import 'package:nomos_types/nomos_types.dart'
     show NomosErrorInfo, NomosUnavailable, nomosErrorFromInfo;
 
+import 'nomos_trace.dart' show NomosTrace;
 import 'replica_readiness.dart' show NmsReplicaWake;
 
 final class NmsTypedWatchHandle<T> {
@@ -30,11 +31,13 @@ final class NmsTypedWatchRegistry {
     required T Function(nomos_protocol.WatchChanged) decode,
     required Future<void> Function(String subscriptionId) start,
     required Future<void> Function(String subscriptionId) stop,
+    String label = '',
   }) {
     if (_closed) throw StateError('Reception watch registry is closed');
     final id = '$session:watch:${++_sequence}';
     late final _TypedWatch<T> watch;
     watch = _TypedWatch<T>(
+      traceFields: NomosTrace.enabled ? 'sub=$id q=$label' : '',
       synced: _synced,
       decode: decode,
       start: () {
@@ -51,7 +54,11 @@ final class NmsTypedWatchRegistry {
         return stop(id);
       },
     );
-    return NmsTypedWatchHandle<T>(id: id, stream: watch.controller.stream);
+    return NmsTypedWatchHandle<T>(
+      id: id,
+      stream: NomosTrace.timedListener(
+          watch.controller.stream, 'sub=$id q=$label stage=deliver'),
+    );
   }
 
   void deliver(nomos_protocol.WatchChanged changed) {
@@ -82,6 +89,7 @@ abstract interface class _RegisteredWatch {
 /// exists, and order cancellation after registration even when it is in flight.
 /// A single-subscription controller buffers the initial response and pauses.
 final class _TypedWatch<T> implements _RegisteredWatch {
+  final String _traceFields;
   final Stream<String>? _synced;
   final T Function(nomos_protocol.WatchChanged) _decode;
   final Future<void> Function() _start;
@@ -91,11 +99,13 @@ final class _TypedWatch<T> implements _RegisteredWatch {
   Future<void>? _stopping;
 
   _TypedWatch({
+    required String traceFields,
     required Stream<String>? synced,
     required T Function(nomos_protocol.WatchChanged) decode,
     required Future<void> Function() start,
     required Future<void> Function() stop,
-  })  : _synced = synced,
+  })  : _traceFields = traceFields,
+        _synced = synced,
         _decode = decode,
         _start = start,
         _stop = stop {
@@ -147,7 +157,20 @@ final class _TypedWatch<T> implements _RegisteredWatch {
       return;
     }
     try {
-      controller.add(_decode(changed));
+      if (NomosTrace.enabled) {
+        // The emission reached its watch; its listener runs later (watch.handler).
+        final started = NomosTrace.now();
+        final value = _decode(changed);
+        NomosTrace.emit(
+            'dart',
+            'watch.deliver',
+            '$_traceFields delta=${changed.hasApplicationDelta()} '
+                'bytes=${changed.applicationResult.value.length + changed.resultUsda.length + changed.applicationDelta.changedRows.value.length} '
+                'decodeUs=${NomosTrace.now() - started}');
+        controller.add(value);
+      } else {
+        controller.add(_decode(changed));
+      }
     } catch (error, stackTrace) {
       controller.addError(error, stackTrace);
     }

package/dart/pubspec.lock

@@ -222,7 +222,7 @@ packages:
       path: "../dart_types"
       relative: true
     source: path
-    version: "0.12.0"
+    version: "0.14.0"
   package_config:
     dependency: "direct main"
     description: