@githolon/dsl 0.108.6 → 0.110.0

package/dart/lib/src/kernel_primitives.dart

@@ -0,0 +1,119 @@
+@internal
+library;
+
+import 'package:meta/meta.dart' show internal;
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
+import 'runtime_v2_transport.dart' show NomosKernelCallTransport;
+
+/// Exact, workspace-independent kernel producers.
+///
+/// These are the clearing house's stamp and key desks: each accepts one named
+/// generated form and returns one named generated form. They own no custody,
+/// session lifecycle, application law or generic command dispatch.
+final class NmsKernelPrimitives {
+  NmsKernelPrimitives({
+    required NomosKernelCallTransport transport,
+    required String session,
+  })  : _transport = transport,
+        _session = session;
+
+  final NomosKernelCallTransport _transport;
+  final String _session;
+  int _sequence = 0;
+
+  Future<nomos_protocol.MintTypedIdResponse> mintTypedId({
+    required String typeTag,
+    required int capturedUnixMillis,
+  }) async {
+    final response = await _call(
+      nomos_protocol.CallRequest(
+        mintTypedId: nomos_protocol.MintTypedIdRequest(
+          typeTag: typeTag,
+          capturedUnixMillis: fixnum.Int64(capturedUnixMillis),
+        ),
+      ),
+    );
+    if (!response.hasMintTypedId()) {
+      throw StateError(
+        'Kernel returned ${response.whichOutcome().name} for typed id mint',
+      );
+    }
+    return response.mintTypedId;
+  }
+
+  Future<nomos_protocol.EncryptionIdentityResponse>
+      generateEncryptionIdentity() async {
+    final response = await _call(
+      nomos_protocol.CallRequest(
+        encryptionIdentity: nomos_protocol.EncryptionIdentityRequest(),
+      ),
+    );
+    if (!response.hasEncryptionIdentity()) {
+      throw StateError(
+        'Kernel returned ${response.whichOutcome().name} for encryption identity',
+      );
+    }
+    return response.encryptionIdentity;
+  }
+
+  Future<nomos_protocol.WrapScopeKeyResponse> wrapScopeKey({
+    required List<int> recipientPublicKey,
+    required List<int> scopeKey,
+  }) async {
+    final response = await _call(
+      nomos_protocol.CallRequest(
+        wrapScopeKey: nomos_protocol.WrapScopeKeyRequest(
+          recipientPublicKey: recipientPublicKey,
+          scopeKey: scopeKey,
+        ),
+      ),
+    );
+    if (!response.hasWrapScopeKey()) {
+      throw StateError(
+        'Kernel returned ${response.whichOutcome().name} for scope-key wrapping',
+      );
+    }
+    return response.wrapScopeKey;
+  }
+
+  Future<nomos_protocol.UnwrapScopeKeyResponse> unwrapScopeKey({
+    required List<int> recipientSecretKey,
+    required List<int> ephemeralPublicKey,
+    required List<int> ciphertext,
+  }) async {
+    final response = await _call(
+      nomos_protocol.CallRequest(
+        unwrapScopeKey: nomos_protocol.UnwrapScopeKeyRequest(
+          recipientSecretKey: recipientSecretKey,
+          ephemeralPublicKey: ephemeralPublicKey,
+          ciphertext: ciphertext,
+        ),
+      ),
+    );
+    if (!response.hasUnwrapScopeKey()) {
+      throw StateError(
+        'Kernel returned ${response.whichOutcome().name} for scope-key unwrapping',
+      );
+    }
+    return response.unwrapScopeKey;
+  }
+
+  Future<nomos_protocol.CallResponse> _call(
+    nomos_protocol.CallRequest request,
+  ) async {
+    request
+      ..protocolVersion = 1
+      ..requestId = '$_session:primitive:${++_sequence}';
+    final response = await _transport.callKernel(
+      session: _session,
+      request: request,
+      credentialUse: nomos_protocol.CredentialUse.CREDENTIAL_USE_NONE,
+    );
+    if (response.hasFailure()) {
+      throw StateError('${response.failure.code}: ${response.failure.message}');
+    }
+    return response;
+  }
+}

package/dart/lib/src/nms_conformance_runtime.dart

@@ -9,4 +9,4 @@ export 'dev_cloud.dart';
 export 'node_runner_transport.dart';
 export 'session_bound.dart';
 export 'test_harness.dart';
-export 'webview_bridge.dart';
+export 'reception/dart_reception.dart';

package/dart/lib/src/nms_generated_runtime.dart

@@ -7,13 +7,21 @@ library;
 import 'package:meta/meta.dart' show internal;
 
 export 'package:nomos_types/nomos_types.dart';
+export 'package:nomos_peer_host/nomos_peer_host.dart'
+    show
+        NomosSignIn,
+        NomosDeviceIdentityStore,
+        NomosProviderCredentialStore,
+        NomosLawPackageSource;
 export 'package:nomos_types/nomos_kernel_protocol.dart'
     show
-        CustodyBreakDecision,
-        CustodyBreakResolved,
-        ModelDifferenceKind,
-        ModelLifecycleResponse,
-        ModelLifecycleStage,
+        ChildWorkspace,
+        ChildWorkspaceStatus,
+        CheckInterfaceCompatibilityRequest,
+        InterfaceCompatibilityResponse,
+        InterfaceCompatibilityVerdict,
+        InterfaceMemberVerdict,
+        LocalLawCurrency,
         WorkspaceSummary;
 export 'package:nomos_types/src/nomos_ref.dart' show NmsInternalNomosRefs;
 export 'package:nomos_types/src/versioned_nomos_ref.dart'
@@ -30,31 +38,45 @@ export 'package:nomos_types/src/foreign_ref.dart'
         ForeignNotFound,
         ForeignDenied,
         ForeignUnreachable;
-export 'home.dart';
-export 'workspace_name.dart';
-export 'webview_bridge.dart';
+export 'reception/dart_reception.dart';
 export 'session_bound.dart';
+export 'application_model_adoption.dart'
+    show
+        NomosApprovedModel,
+        NomosModelAdoption,
+        NomosModelAdoptionDeferred,
+        NomosModelAdoptionOutcome,
+        NomosModelAdoptionPhase,
+        NomosModelAdoptionProgress;
 export 'provider.dart';
 export 'record_origin.dart';
-export 'source_trust.dart';
 export 'generated_call.dart'
     show
         NmsGeneratedCall,
         NmsGeneratedQuery,
+        NmsGeneratedResult,
         NmsInternalGeneratedCalls,
-        NmsInternalGeneratedQueries;
+        NmsInternalGeneratedQueries,
+        NmsInternalGeneratedResults;
 export 'application_framework_calls.dart' show OwnedCustody, OwnedDeviceRequest;
 export 'result_usda.dart'
     show
         NmsUsdaPrim,
+        NmsUsdaLayer,
         NmsUsdaResult,
         NmsUsdaConflictResult,
         NmsUsdaConflictCount,
         NmsUsdaConflictSummaryResult;
 export 'runtime_v2_transport.dart'
     show
+        NmsPlatformCredentialProviderHost,
+        NomosPlatformCredentialProviders,
+        NomosSessionCredentials,
         NomosKernelCallTransport,
         NomosRuntimeV2Transport,
         NomosRuntimeV2EventTransport,
         NomosRuntimeV2KernelCalls,
         NmsBufferedRuntimeEvents;
+export 'reception/peer_office_connection.dart' show PeerOfficeConnection;
+
+export 'admission_decision.dart';

package/dart/lib/src/nms_test_environment.dart

@@ -5,4 +5,4 @@ library;
 import 'package:meta/meta.dart' show internal;
 
 export 'dev_cloud.dart' show DevIdentityToken, NomosTestCloud;
-export 'test_harness.dart' show NomosTestHarness;
+export 'test_harness.dart' show NomosTestHarness, NomosTestFrontier;

package/dart/lib/src/node_runner_transport.dart

@@ -1,12 +1,12 @@
-// THE HEADLESS (NODE) TRANSPORT — a [BridgeTransport] over the `@githolon/client` node runner
-// (`runner/node-entry.ts`), spawned as a plain child process speaking the ONE bridge protocol as
-// newline-delimited JSON on stdio. This is what lets `dart test` / `flutter test` / CI drive the REAL
-// githolon (the byte-identical wasm, the real ledger, the real gate) through [NomosBridge] and the
+// THE NODE PEER CONNECTION — a [PeerOfficeConnection] over the `@githolon/runtime` node runner
+// (`runner/node-entry.ts`), spawned as a plain child process carrying generated
+// Runtime v2 protobuf frames over base64-delimited stdio. This lets `dart test` / `flutter test` / CI drive the REAL
+// githolon (the byte-identical wasm, the real ledger, the real gate) through Reception and the
 // generated typed clients — no Flutter plugins, no WebView, no assets. The only environment requirement
-// is `node` on PATH plus a resolvable `@githolon/client` (any app that compiles domains already has both).
+// is `node` on PATH plus a resolvable `@githolon/runtime` (any app that compiles domains already has both).
 //
-// This file is a PURE RELAY: no orchestration, no op knowledge — the protocol implementation lives in
-// createWebviewRunner (shared with the WebView path) and the orchestration in index.mjs, same as every peer.
+// This file is a PURE RELAY: no orchestration and no operation knowledge. The
+// child runs the same peer-runtime component as every other platform.
 @internal
 library;
 
@@ -23,17 +23,19 @@ import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
 import 'runtime_v2_transport.dart'
     show
         NmsBufferedRuntimeEvents,
+        NmsPlatformCredentialProviderHost,
         NomosRuntimeV2EventTransport,
         NomosRuntimeV2KernelCalls,
         NomosRuntimeV2Transport;
-import 'webview_bridge.dart' show BridgeTransport;
+import 'reception/peer_office_connection.dart' show PeerOfficeConnection;
 
 class NodeRunnerTransport
-    with NomosRuntimeV2KernelCalls
-    implements BridgeTransport, NomosRuntimeV2Transport, NomosRuntimeV2EventTransport {
+    with NomosRuntimeV2KernelCalls, NmsPlatformCredentialProviderHost
+    implements
+        PeerOfficeConnection,
+        NomosRuntimeV2Transport,
+        NomosRuntimeV2EventTransport {
   final Process _proc;
-  final StreamController<Map<String, Object?>> _incoming =
-      StreamController<Map<String, Object?>>.broadcast();
   final NmsBufferedRuntimeEvents _runtimeEvents = NmsBufferedRuntimeEvents();
   final void Function(String line)? _onDiagnostic;
   final Map<int, Completer<nomos_protocol.RuntimeResponse>> _runtimeReplies =
@@ -64,28 +66,24 @@ class NodeRunnerTransport
       }
       if (s.startsWith('runtime-v2-event:')) {
         try {
-          _runtimeEvents.add(nomos_protocol.RuntimeEvent.fromBuffer(
+          final event = nomos_protocol.RuntimeEvent.fromBuffer(
             base64Decode(s.substring('runtime-v2-event:'.length)),
-          ));
+          );
+          if (!consumeCredentialRefreshEvent(
+              event, this, _runtimeEvents.addError)) {
+            _runtimeEvents.add(event);
+          }
         } catch (error, stackTrace) {
           _runtimeEvents.addError(error, stackTrace);
         }
         return;
       }
-      Object? decoded;
-      try {
-        decoded = jsonDecode(s);
-      } catch (_) {
-        _diag('[nomos-node-runner stdout] $line');
-        return;
-      }
-      if (decoded is Map && !_incoming.isClosed) {
-        _incoming.add(decoded.cast<String, Object?>());
-      }
+      _diag('[nomos-node-runner unexpected stdout] $line');
     }, onDone: () {
-      if (!_disposed && !_incoming.isClosed) {
-        _incoming
-            .addError(StateError('the nomos node runner exited unexpectedly'));
+      if (!_disposed && !_runtimeEvents.isClosed) {
+        _runtimeEvents.addError(
+          StateError('the Nomos node peer exited unexpectedly'),
+        );
       }
     });
     _proc.stderr
@@ -104,17 +102,18 @@ class NodeRunnerTransport
   }
 
   /// Spawn the node runner and return the connected transport. Wrap it in a
-  /// [NomosBridge] and `await bridge.ready` (the runner posts `{event:'ready'}`
-  /// on boot), then `connect(...)` as any other transport.
+  /// [DartReception] and `await reception.ready` (the runner posts `{event:'ready'}`
+  /// on boot), then bind an interaction as with any other transport.
   ///
   /// [entry] — path to `node-entry.ts`. When omitted it is resolved with
-  /// `require.resolve('@githolon/client/runner/node-entry.ts')` from
+  /// `require.resolve('@githolon/runtime/runner/node-entry.ts')` from
   /// [resolveFrom] (default: the current directory), i.e. the consuming app's
   /// own `node_modules`.
   static Future<NodeRunnerTransport> start({
     String? entry,
     String? resolveFrom,
     String node = 'node',
+    List<String> arguments = const <String>[],
     Map<String, String>? environment,
     void Function(String line)? onDiagnostic,
   }) async {
@@ -122,7 +121,7 @@ class NodeRunnerTransport
         await _resolveEntry(node, resolveFrom ?? Directory.current.path);
     final proc = await Process.start(
       node,
-      [entryPath],
+      [entryPath, ...arguments],
       environment: environment,
       // [resolveFrom] locates a packaged runner when [entry] is omitted; it is not a runtime dependency of
       // an explicit, self-contained entry. Reusing it as cwd made copied release tests fail with ENOENT even
@@ -162,8 +161,8 @@ class NodeRunnerTransport
       }
     }
     for (final entry in const [
-      '@githolon/client/runner/node-entry.mjs',
-      '@githolon/client/runner/node-entry.ts',
+      '@githolon/runtime/runner/node-entry.mjs',
+      '@githolon/runtime/runner/node-entry.ts',
     ]) {
       final r = await Process.run(
         node,
@@ -174,27 +173,24 @@ class NodeRunnerTransport
       if (r.exitCode == 0 && out.isNotEmpty) return out;
     }
     throw StateError('the Nomos release contains no bundled node runner and no '
-        '@githolon/client runner is installed; reinstall nomos_client');
+        '@githolon/runtime runner is installed; reinstall nomos_client');
   }
 
   @override
-  Stream<Map<String, Object?>> get messages => _incoming.stream;
-
-  @override
-  Stream<nomos_protocol.RuntimeEvent> get runtimeEvents => _runtimeEvents.stream;
+  Stream<nomos_protocol.RuntimeEvent> get runtimeEvents =>
+      _runtimeEvents.stream;
 
-  @override
-  void send(Map<String, Object?> message) {
-    if (_disposed) throw StateError('NodeRunnerTransport is disposed');
-    _proc.stdin.writeln(jsonEncode(message));
-  }
-
-  /// Exchange one exact generated Runtime v2 frame with the headless runner.
+  /// Exchange one exact generated Runtime v2 frame with the spawned node peer.
   /// The line prefix/base64 is only stdio framing; the command and result are
   /// protobuf and are never reconstructed as a JSON object or operation name.
   @override
   Future<nomos_protocol.RuntimeResponse> invokeRuntime(
     nomos_protocol.RuntimeRequest request,
+  ) =>
+      driveCredentialEffects(request, _invokeRuntimeFrame);
+
+  Future<nomos_protocol.RuntimeResponse> _invokeRuntimeFrame(
+    nomos_protocol.RuntimeRequest request,
   ) {
     if (_disposed) throw StateError('NodeRunnerTransport is disposed');
     final id = request.requestId.toInt();
@@ -233,7 +229,6 @@ class NodeRunnerTransport
       _proc.kill(ProcessSignal.sigkill);
       return -9;
     });
-    await _incoming.close();
     await _runtimeEvents.close();
   }
 }

package/dart/lib/src/observed_session_directory.dart

@@ -0,0 +1,70 @@
+/// Disposable Dart projection of sessions owned by the peer runtime.
+///
+/// This directory is not custody, placement, authentication, or lifecycle
+/// authority. It remembers only which Runtime v2 bindings have succeeded and
+/// provides stable typed façade handles for application code.
+library;
+
+final class _NmsObservedSession {
+  const _NmsObservedSession({
+    required this.workspace,
+    required this.credentialCapability,
+  });
+
+  final String workspace;
+  final String credentialCapability;
+}
+
+final class NmsObservedSessionDirectory<THandle> {
+  // One observation record owns the successful-bind fact. A separate Set and
+  // workspace/capability maps would be three mutable copies requiring fan-out.
+  final Map<String, _NmsObservedSession> _bindings = {};
+  final Map<String, THandle> _handles = {};
+
+  Iterable<String> get boundNames => _bindings.keys;
+  int get boundCount => _bindings.length;
+  bool get hasBoundSessions => _bindings.isNotEmpty;
+  String get soleBoundSession => _bindings.keys.single;
+
+  bool isBound(String session) => _bindings.containsKey(session);
+
+  List<String> boundSnapshot() => List.unmodifiable(_bindings.keys);
+
+  String workspaceFor(String session) =>
+      _bindings[session]?.workspace ?? session;
+
+  String credentialCapabilityFor(String session) {
+    final observed = _bindings[session];
+    if (observed == null) {
+      throw StateError("Nomos session '$session' is not bound");
+    }
+    return observed.credentialCapability;
+  }
+
+  void observeBound({
+    required String session,
+    required String workspace,
+    required String credentialCapability,
+  }) {
+    if (credentialCapability.isEmpty) {
+      throw StateError(
+        "Nomos runtime bound '$session' without a credential capability identity",
+      );
+    }
+    final observed = _bindings[session];
+    if (observed != null &&
+        (observed.workspace != workspace ||
+            observed.credentialCapability != credentialCapability)) {
+      throw StateError(
+        "Nomos session '$session' changed identity after binding",
+      );
+    }
+    _bindings[session] = _NmsObservedSession(
+      workspace: workspace,
+      credentialCapability: credentialCapability,
+    );
+  }
+
+  THandle handle(String session, THandle Function() create) =>
+      _handles.putIfAbsent(session, create);
+}

package/dart/lib/src/operation_receipts.dart

@@ -0,0 +1,112 @@
+import 'dart:async';
+
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
+enum NomosOperationPhase {
+  locallyAccepted,
+  admittedToRemoteCustody,
+  converged,
+}
+
+/// Product-facing progress for one accepted write.
+final class NomosOperationStatus {
+  const NomosOperationStatus(this.phase, {this.updatedAt});
+
+  final NomosOperationPhase phase;
+  final DateTime? updatedAt;
+
+  bool get isAdmitted => phase != NomosOperationPhase.locallyAccepted;
+  bool get isConverged => phase == NomosOperationPhase.converged;
+}
+
+/// Awaitable projection of typed peer-runtime receipts for one stable intent.
+final class NomosOperationReceipt {
+  NomosOperationReceipt._()
+      : _status =
+            const NomosOperationStatus(NomosOperationPhase.locallyAccepted),
+        _changes = StreamController<NomosOperationStatus>.broadcast();
+
+  NomosOperationStatus _status;
+  final StreamController<NomosOperationStatus> _changes;
+
+  NomosOperationStatus get current => _status;
+
+  Stream<NomosOperationStatus> watch() async* {
+    yield _status;
+    yield* _changes.stream;
+  }
+
+  Future<void> get admitted => _status.isAdmitted
+      ? Future<void>.value()
+      : watch().firstWhere((status) => status.isAdmitted).then((_) {});
+
+  Future<void> get converged => _status.isConverged
+      ? Future<void>.value()
+      : watch().firstWhere((status) => status.isConverged).then((_) {});
+
+  void _advance(NomosOperationPhase phase) {
+    if (phase.index <= _status.phase.index) return;
+    _status = NomosOperationStatus(phase, updatedAt: DateTime.now());
+    if (!_changes.isClosed) _changes.add(_status);
+    if (phase == NomosOperationPhase.converged) unawaited(_changes.close());
+  }
+
+  void _close() {
+    if (!_changes.isClosed) unawaited(_changes.close());
+  }
+}
+
+/// One disposable application projection of kernel-authenticated receipt IDs.
+/// It never manufactures an admission verdict or persists business history.
+final class NmsOperationReceiptProjection {
+  final Map<String, Map<String, NomosOperationReceipt>> _pending = {};
+  final Map<String, NomosOperationReceipt> _births = {};
+
+  NomosOperationReceipt register(String workspace, String intentId) {
+    if (intentId.isEmpty) {
+      throw StateError(
+        'Nomos accepted a local write without returning its stable intent identity. '
+        'The runtime and kernel release are incompatible.',
+      );
+    }
+    return _pending
+        .putIfAbsent(workspace, () => {})
+        .putIfAbsent(intentId, NomosOperationReceipt._);
+  }
+
+  void rememberBirth(String workspace, NomosOperationReceipt receipt) {
+    _births[workspace] = receipt;
+  }
+
+  NomosOperationReceipt? birthFor(String workspace) => _births[workspace];
+
+  void advance(String workspace, nomos_protocol.SyncWorkspaceResponse result) {
+    final pending = _pending[workspace];
+    if (pending == null || pending.isEmpty) return;
+
+    for (final intentId in result.admittedIntentIds.where(
+      (value) => value.isNotEmpty,
+    )) {
+      pending[intentId]?._advance(NomosOperationPhase.admittedToRemoteCustody);
+    }
+    for (final intentId in result.convergedIntentIds.where(
+      (value) => value.isNotEmpty,
+    )) {
+      final receipt = pending.remove(intentId);
+      receipt?._advance(NomosOperationPhase.converged);
+    }
+    if (pending.isEmpty) _pending.remove(workspace);
+  }
+
+  void close() {
+    final receipts = <NomosOperationReceipt>{
+      for (final workspace in _pending.values) ...workspace.values,
+      ..._births.values,
+    };
+    _pending.clear();
+    _births.clear();
+    for (final receipt in receipts) {
+      receipt._close();
+    }
+  }
+}

package/dart/lib/src/peer_application_streams.dart

@@ -0,0 +1,103 @@
+import 'application_status.dart' show ApplicationStatus;
+import 'nms_generated_runtime.dart' show NomosSession, SyncStatus;
+import 'workspace_open_progress.dart' show ApplicationWorkspaceOpenProgress;
+
+/// Dart's language-native view of Peer Office observations.
+///
+/// Peer Office owns the underlying subscriptions, reconnect policy and event
+/// production. This desk owns only the Dart adaptation: listening creates a
+/// subscription to the already-running peer event plane and cancelling the
+/// listener releases that subscription. It never starts synchronization.
+abstract interface class NmsPeerApplicationStreams {
+  Stream<ApplicationStatus> get status;
+  Stream<ApplicationStatus> get applicationStatus;
+  Stream<ApplicationWorkspaceOpenProgress> workspaceOpenProgress(
+    String workspace,
+  );
+  Stream<void> get childWorkspaces;
+  /// Any accepted local or remote change which may invalidate a generated
+  /// application projection. Interpretation remains in generated law-aware code.
+  Stream<void> get workspaceChanges;
+
+  /// Re-read one application projection initially and after any typed change
+  /// signal, coalescing changes which arrive while the read is in flight.
+  Stream<T> refreshOn<T>({
+    required Future<T> Function() read,
+    required Iterable<Stream<void>> changes,
+  });
+}
+
+final class NmsPeerApplicationStreamView implements NmsPeerApplicationStreams {
+  const NmsPeerApplicationStreamView({
+    required this.session,
+    required this.statusProjection,
+    this.workspaceOpenProgressSource,
+  });
+
+  final NomosSession session;
+  final ApplicationStatus Function(SyncStatus status) statusProjection;
+  final Stream<ApplicationWorkspaceOpenProgress> Function(String workspace)?
+      workspaceOpenProgressSource;
+
+  @override
+  Stream<ApplicationStatus> get status =>
+      session.syncStatus.map(statusProjection);
+
+  @override
+  Stream<ApplicationStatus> get applicationStatus =>
+      session.parent.syncStatus.map(statusProjection);
+
+  @override
+  Stream<ApplicationWorkspaceOpenProgress> workspaceOpenProgress(
+    String workspace,
+  ) =>
+      workspaceOpenProgressSource?.call(workspace) ??
+      const Stream<ApplicationWorkspaceOpenProgress>.empty();
+
+  @override
+  Stream<void> get childWorkspaces => session.syncEvents.map<void>((_) {});
+
+  @override
+  Stream<void> get workspaceChanges => session.syncEvents.map<void>((_) {});
+
+  @override
+  Stream<T> refreshOn<T>({
+    required Future<T> Function() read,
+    required Iterable<Stream<void>> changes,
+  }) =>
+      Stream<T>.multi((events) {
+        var reading = false;
+        var reread = false;
+
+        Future<void> refresh() async {
+          if (reading) {
+            reread = true;
+            return;
+          }
+          reading = true;
+          do {
+            reread = false;
+            try {
+              final value = await read();
+              if (!events.isClosed) events.add(value);
+            } catch (error, stackTrace) {
+              if (!events.isClosed) events.addError(error, stackTrace);
+            }
+          } while (reread && !events.isClosed);
+          reading = false;
+        }
+
+        final subscriptions = changes
+            .map((stream) => stream.listen(
+                  (_) => refresh(),
+                  onError: events.addError,
+                ))
+            .toList(growable: false);
+        events.onCancel = () async {
+          for (final subscription in subscriptions) {
+            await subscription.cancel();
+          }
+        };
+        refresh();
+      });
+}