@githolon/dsl 0.108.0 → 0.108.2

package/dart/lib/src/runtime_v2_gateway.dart

@@ -0,0 +1,54 @@
+@internal
+library;
+
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+import 'package:nomos_types/nomos_types.dart'
+    show NomosErrorInfo, nomosErrorFromInfo;
+
+import 'runtime_v2_transport.dart';
+
+/// Correlates generated Runtime v2 frames and translates only the generated
+/// failure arm. It knows nothing about sessions, domains, lifecycle policy, or
+/// application state; those remain with the caller that owns each command.
+final class NmsRuntimeV2Gateway {
+  NmsRuntimeV2Gateway(this._transport);
+
+  final NomosRuntimeV2Transport _transport;
+  int _sequence = 0;
+
+  Future<nomos_protocol.RuntimeResponse> invoke(
+    nomos_protocol.RuntimeRequest request,
+  ) async {
+    final requestId = fixnum.Int64(++_sequence);
+    request
+      ..protocolVersion = 2
+      ..requestId = requestId;
+    final response = await _transport.invokeRuntime(request);
+    if (response.protocolVersion != 2) {
+      throw StateError(
+        'Nomos host returned Runtime protocol ${response.protocolVersion}',
+      );
+    }
+    if (response.requestId != requestId) {
+      throw StateError(
+        'Runtime v2 response ${response.requestId} belongs to another request',
+      );
+    }
+    if (response.hasFailure()) {
+      final failure = response.failure;
+      throw nomosErrorFromInfo(
+        NomosErrorInfo(
+          code: failure.code,
+          message: failure.message,
+          component: failure.component,
+          workspace: failure.hasWorkspace() ? failure.workspace : null,
+          domain: failure.hasDomain() ? failure.domain : null,
+          directiveId: failure.hasDirective() ? failure.directive : null,
+        ),
+      );
+    }
+    return response;
+  }
+}

package/dart/lib/src/runtime_v2_transport.dart

@@ -0,0 +1,117 @@
+@internal
+library;
+
+import 'dart:async';
+
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
+/// Binary generated-message path from an application host to the kernel.
+abstract interface class NomosKernelCallTransport {
+  Future<nomos_protocol.CallResponse> callKernel({
+    required String session,
+    required nomos_protocol.CallRequest request,
+  });
+}
+
+/// Exact Runtime v2 frame exchange. Platform transports carry bytes; they do
+/// not acquire command names, argument bags, or domain result semantics.
+abstract interface class NomosRuntimeV2Transport {
+  Future<nomos_protocol.RuntimeResponse> invokeRuntime(
+    nomos_protocol.RuntimeRequest request,
+  );
+}
+
+/// Generated asynchronous runtime event lane. It is separate from invocation
+/// correlation because a watch/sync event has no request future to complete.
+abstract interface class NomosRuntimeV2EventTransport {
+  Stream<nomos_protocol.RuntimeEvent> get runtimeEvents;
+}
+
+/// A level-triggered generated event stream. Runtime readiness can arrive while
+/// a WebView script is loading, before [NomosBridge] exists; a broadcast stream
+/// would silently discard it and turn a successful boot into an infinite wait.
+/// Buffering ends when the first bridge subscribes, after which events remain a
+/// normal broadcast stream.
+final class NmsBufferedRuntimeEvents {
+  NmsBufferedRuntimeEvents() {
+    _controller = StreamController<nomos_protocol.RuntimeEvent>.broadcast(
+      onListen: _attach,
+    );
+  }
+
+  late final StreamController<nomos_protocol.RuntimeEvent> _controller;
+  final List<nomos_protocol.RuntimeEvent> _pending = [];
+  bool _attached = false;
+
+  Stream<nomos_protocol.RuntimeEvent> get stream => _controller.stream;
+  bool get isClosed => _controller.isClosed;
+
+  void _attach() {
+    if (_attached) return;
+    _attached = true;
+    final pending = List<nomos_protocol.RuntimeEvent>.of(_pending);
+    _pending.clear();
+    for (final event in pending) {
+      if (!_controller.isClosed) _controller.add(event);
+    }
+  }
+
+  void add(nomos_protocol.RuntimeEvent event) {
+    if (_controller.isClosed) return;
+    if (_attached) {
+      _controller.add(event);
+    } else {
+      _pending.add(event);
+    }
+  }
+
+  void addError(Object error, [StackTrace? stackTrace]) {
+    if (_controller.isClosed) return;
+    _controller.addError(error, stackTrace);
+  }
+
+  Future<void> close() {
+    _pending.clear();
+    return _controller.close();
+  }
+}
+
+/// Shared typed kernel-call lowering for every Runtime v2 transport.
+mixin NomosRuntimeV2KernelCalls
+    implements NomosRuntimeV2Transport, NomosKernelCallTransport {
+  int _nmsRuntimeRequestSequence = 0;
+
+  @override
+  Future<nomos_protocol.CallResponse> callKernel({
+    required String session,
+    required nomos_protocol.CallRequest request,
+  }) async {
+    final requestId = fixnum.Int64(++_nmsRuntimeRequestSequence);
+    final response = await invokeRuntime(
+      nomos_protocol.RuntimeRequest(
+        protocolVersion: 2,
+        requestId: requestId,
+        kernelCall: nomos_protocol.KernelCallRequest(
+          session: session,
+          request: request,
+        ),
+      ),
+    );
+    if (response.requestId != requestId) {
+      throw StateError(
+        'Runtime v2 response ${response.requestId} belongs to another request',
+      );
+    }
+    if (response.hasFailure()) {
+      throw StateError('${response.failure.code}: ${response.failure.message}');
+    }
+    if (!response.hasKernelCall()) {
+      throw StateError(
+        'Runtime v2 returned ${response.whichOutcome().name} for a kernel call',
+      );
+    }
+    return response.kernelCall;
+  }
+}

package/dart/lib/src/session_bound.dart

@@ -28,6 +28,8 @@ import 'package:meta/meta.dart' show internal;
 
 import 'dart:convert';
 
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
 import 'webview_bridge.dart';
 
 /// The STATIC INTERFACE DESCRIPTOR a generated client exposes as `XClient.interface` — what the
@@ -474,8 +476,11 @@ extension NomosSessionCompat on NomosSession {
         final m = await metrics();
         behind = ((m['behind'] as num?) ?? 0).toInt();
         final listed = await listWorkspaces();
-        cloudBound = listed.any((w) =>
-            w['workspace'] == workspace && w['syncPosture'] == 'cloud-bound');
+        cloudBound = listed.any((candidate) =>
+            candidate.workspace == workspace &&
+            candidate.syncPosture ==
+                nomos_protocol
+                    .WorkspaceSyncPosture.WORKSPACE_SYNC_POSTURE_CLOUD_BOUND);
       } catch (_) {/* best-effort */}
       if (cloudBound && behind > 0) {
         cause = SessionMismatchCause.liveCloudHasLawButLocalStale;

package/dart/lib/src/test_harness.dart

@@ -42,10 +42,13 @@ import 'dart:io';
 
 import 'package:crypto/crypto.dart' show sha256;
 import 'package:fixnum/fixnum.dart' show Int64;
-import 'package:nomos_types/nomos_kernel_protocol.dart' show BirthCertificate;
+import 'package:nomos_types/nomos_kernel_protocol.dart'
+    show BirthCertificate, BirthOutcomeStatus, SyncWorkspaceResponse;
+import 'package:nomos_types/nomos_types.dart' show Sha256Digest;
 import 'package:package_config/package_config.dart' show loadPackageConfigUri;
 
 import 'dev_cloud.dart';
+import 'application_framework_calls.dart';
 import 'node_runner_transport.dart';
 import 'session_bound.dart' show DomainNotInstalledForSession;
 import 'webview_bridge.dart' show NomosBridge, NomosSession;
@@ -250,36 +253,13 @@ Future<String?> _sourceCandidateRuntime(String nodeEntry) async {
 /// Framework-internal classifier for a sync result that can never become converged by retrying. Generated
 /// scenarios use it through [NomosTestHarness.converge]; it is public only inside `package:nomos_client/src`
 /// so the false-green contract has a cheap regression test without booting a cloud.
-String? nmsPermanentConvergenceFailure(Map<String, Object?> result) {
-  final admission = result['admission'];
-  final sessions = admission is Map && admission['sessions'] is List
-      ? admission['sessions'] as List
-      : const [];
-  final rejected = sessions
-      .whereType<Map>()
-      .expand(
-        (session) => session['rejected'] is List
-            ? session['rejected'] as List
-            : const [],
-      )
-      .toList();
-  final deadLetters = admission is Map && admission['deadLetters'] is List
-      ? admission['deadLetters'] as List
-      : const [];
-  final converged = result['converged'];
-  final replayDeadLetters =
-      converged is Map && converged['deadLettered'] is List
-          ? converged['deadLettered'] as List
-          : const [];
-  final pushError = result['pushError'];
-  final refused = pushError is Map && pushError['refused'] == true;
-  if (rejected.isEmpty &&
-      deadLetters.isEmpty &&
-      replayDeadLetters.isEmpty &&
-      !refused) {
+String? nmsPermanentConvergenceFailure(SyncWorkspaceResponse result) {
+  final transportRefused = result.hasPushError() && result.pushError.refused;
+  if (result.refused == 0 && !transportRefused) {
     return null;
   }
-  return jsonEncode(result);
+  return 'refused=${result.refused}, '
+      'push=${result.hasPushError() ? result.pushError.message : "none"}';
 }
 
 /// The offline-install lane configuration a harness keeps so the CUSTODY DIAGNOSTIC helpers
@@ -615,6 +595,7 @@ class NomosTestHarness {
   /// [autoTearDown] — when true (default) and [registerTearDown] is given, registers [dispose] as a teardown.
   static Future<NomosTestHarness> ephemeral({
     required List<String> lawUsdzPaths,
+    NmsApplicationFrameworkCalls? applicationFrameworkCalls,
     int? applicationMaxChildWorkspacesPerUser,
     String? ownerSubject,
     String workspace = 'test-ws',
@@ -665,6 +646,12 @@ class NomosTestHarness {
     final birthsApplicationHome = owner != null &&
         owner.isNotEmpty &&
         workspace == _receivingGroupNameOf(owner);
+    if (birthsApplicationHome && applicationFrameworkCalls == null) {
+      throw NomosTestHarnessException(
+        'a generated application scenario must pass its compiler-generated framework calls; '
+        'the harness cannot construct domain payloads',
+      );
+    }
     // A receiving-group address is not an arbitrary law-install target. It is valid only when a parent
     // births it with the attestation, signer seating and warrant ordered into genesis. Generated scenarios
     // therefore install their package on a private throwaway application parent and exercise the same local
@@ -804,49 +791,151 @@ class NomosTestHarness {
           // scenario carries the value from the same package declaration that compiled the
           // receiving-group plan; the harness does not choose or default it. The ordinary
           // seed offer crosses the kernel author gate before the first birth is attempted.
-          run: () => plane.session(installWorkspace).offerOutcome(
-            domain: '__nomos_application_home_v1',
-            directiveId: 'seedBirthPolicy',
-            actor: owner,
-            authorSecret: deviceSecret,
-            payload: <String, Object?>{
-              'maxBirthsPerPrincipal': maxChildWorkspaces,
-              'setBy': owner,
-              'setAt': bornAt,
-            },
-          ),
+          run: () => plane.session(installWorkspace).offerCallUsdaOutcome(
+                call: applicationFrameworkCalls!.seedBirthPolicy(
+                  domain: '__nomos_application_home_v1',
+                  workspace: installWorkspace,
+                  maxBirthsPerPrincipal: maxChildWorkspaces,
+                  setBy: owner,
+                  setAt: bornAt,
+                ),
+                actor: owner,
+              ),
+        );
+        final keyHash = sha256.convert(base64Decode(devicePublic)).toString();
+        await _phased(
+          phase: 'application: seat the verified parent signer',
+          workspace: installWorkspace,
+          awaiting: 'law-declared enrollSigner offer',
+          timeout: phaseTimeout ?? _kOtherDeadline,
+          onDiagnostic: onDiagnostic,
+          run: () => plane.session(installWorkspace).offerCallUsdaOutcome(
+                call: applicationFrameworkCalls!.enrollSigner(
+                  domain: '__nomos_application_home_v1',
+                  workspace: installWorkspace,
+                  keyHash: keyHash,
+                  grantedBy: owner,
+                  grantedAt: 1,
+                  verifiedVia: 'nomos:test-mint',
+                ),
+                actor: owner,
+              ),
         );
+        final delegationCert =
+            await plane.session(installWorkspace).signBirthCert(
+                  BirthCertificate(
+                    child: workspace,
+                    founder: owner,
+                    verified: true,
+                    parentKey: base64Decode(devicePublic),
+                    parentId: 'root',
+                    epoch: Int64.ZERO,
+                  ),
+                  deviceSecret,
+                );
+        await _phased(
+          phase: 'application: record the parent-signed device delegation',
+          workspace: installWorkspace,
+          awaiting: 'law-declared enrollDelegation offer',
+          timeout: phaseTimeout ?? _kOtherDeadline,
+          onDiagnostic: onDiagnostic,
+          run: () => plane.session(installWorkspace).offerCallUsdaOutcome(
+                call: applicationFrameworkCalls!.enrollDelegation(
+                  domain: '__nomos_application_home_v1',
+                  workspace: installWorkspace,
+                  user: owner,
+                  deviceKey: devicePublic,
+                  certificate: delegationCert,
+                  enrolledAt: '1970-01-01T00:00:00.000Z',
+                ),
+                actor: owner,
+              ),
+        );
+        final parentCert = await plane.session(installWorkspace).signBirthCert(
+              BirthCertificate(
+                child: installWorkspace,
+                founder: owner,
+                verified: true,
+                parentKey: base64Decode(devicePublic),
+                parentId: 'root',
+                epoch: Int64.ZERO,
+              ),
+              deviceSecret,
+            );
+        await _phased(
+          phase: 'application: attest and warrant the application parent',
+          workspace: installWorkspace,
+          awaiting: 'typed birth attestation and genesis offers',
+          timeout: phaseTimeout ?? _kOtherDeadline,
+          onDiagnostic: onDiagnostic,
+          run: () async {
+            await plane.session(installWorkspace).offerCallUsdaOutcome(
+                  call: applicationFrameworkCalls!.seedBirthAttestation(
+                    domain: '__nomos_application_home_v1',
+                    workspace: installWorkspace,
+                    child: installWorkspace,
+                    founder: owner,
+                    verified: 'true',
+                    parentId: 'root',
+                    parentKey: devicePublic,
+                    epoch: 0,
+                    links: <BirthCertificate>[parentCert],
+                  ),
+                  actor: owner,
+                );
+            await plane.session(installWorkspace).offerCallUsdaOutcome(
+                  call: applicationFrameworkCalls.seedGenesis(
+                    domain: '__nomos_application_home_v1',
+                    workspace: installWorkspace,
+                    principal: owner,
+                    workspaceId: installWorkspace,
+                    bornAt: '1970-01-01T00:00:00.000Z',
+                  ),
+                  actor: owner,
+                );
+          },
+        );
+        final homeCert = await plane.session(installWorkspace).signBirthCert(
+              BirthCertificate(
+                child: workspace,
+                founder: owner,
+                verified: true,
+                parentKey: base64Decode(devicePublic),
+                parentId: installWorkspace,
+                epoch: Int64.ZERO,
+              ),
+              deviceSecret,
+            );
         final outcome = await _phased(
           phase: 'application: birth the signed-in application',
           workspace: workspace,
           awaiting: 'attested receiving-group birth',
           timeout: phaseTimeout ?? _kOtherDeadline,
           onDiagnostic: onDiagnostic,
-          run: () => plane.session(installWorkspace).offerOutcome(
-            domain: '__nomos_application_home_v1',
-            directiveId: 'nomosInternalBirthReceivingGroup7c1f5e',
-            actor: owner,
-            authorSecret: deviceSecret,
-            payload: <String, Object?>{
-              'owner': owner,
-              'frameworkHash': framework,
-              // Ordered application deployment is reference packages first, deferred child payload last.
-              // The parent serves the references; the receiving group is born with only its payload law.
-              'lawHash': laws.last,
-              'bornAt': bornAt,
-            },
-          ),
+          run: () => plane.session(installWorkspace).offerCallUsdaOutcome(
+                call: applicationFrameworkCalls!.birthReceivingGroup(
+                  domain: '__nomos_application_home_v1',
+                  workspace: installWorkspace,
+                  owner: owner,
+                  frameworkHash: Sha256Digest(framework),
+                  lawHash: Sha256Digest(laws.last),
+                  bornAt: bornAt,
+                ),
+                actor: owner,
+                authorSecret: deviceSecret,
+                birthCertificate: homeCert,
+              ),
         );
         String? bornStatus;
         for (final entry in outcome.birthOutcomes) {
-          if (entry['workspace']?.toString() == workspace) {
-            bornStatus = entry['status']?.toString();
+          if (entry.workspace == workspace) {
+            bornStatus = entry.status.name;
             break;
           }
         }
         if (outcome.born.length != 1 ||
             outcome.born.single != workspace ||
-            bornStatus != 'born') {
+            bornStatus != 'BIRTH_OUTCOME_STATUS_BORN') {
           throw NomosTestHarnessException(
             'the offline application parent did not birth "$workspace" cleanly '
             '(born=${outcome.born}, birthOutcomes=${outcome.birthOutcomes})',
@@ -889,18 +978,17 @@ class NomosTestHarness {
             // harness device through the installed framework law with the same verified provenance
             // that the private test root later attests. Production clients never manufacture this
             // marker; it exists only inside the offline test-mint ceremony.
-            run: () => plane.session(workspace).offerOutcome(
-              domain: '__nomos_application_home_v1',
-              directiveId: 'enrollSigner',
-              actor: owner,
-              authorSecret: deviceSecret,
-              payload: <String, Object?>{
-                'keyHash': keyHash,
-                'grantedBy': owner,
-                'grantedAt': 1,
-                'verifiedVia': 'nomos:test-mint',
-              },
-            ),
+            run: () => plane.session(workspace).offerCallUsdaOutcome(
+                  call: applicationFrameworkCalls!.enrollSigner(
+                    domain: '__nomos_application_home_v1',
+                    workspace: workspace,
+                    keyHash: keyHash,
+                    grantedBy: owner,
+                    grantedAt: 1,
+                    verifiedVia: 'nomos:test-mint',
+                  ),
+                  actor: owner,
+                ),
           );
         } catch (error) {
           // Pre-application-home packages neither expose nor enforce this
@@ -921,22 +1009,24 @@ class NomosTestHarness {
             timeout: phaseTimeout ?? _kOtherDeadline,
             onDiagnostic: onDiagnostic,
             run: () async {
-              await plane.session(workspace).offerOutcome(
-                domain: '__nomos_application_home_v1',
-                directiveId: 'nomosInternalSeedReceivingGroupPolicy7c1f5e',
-                actor: 'host-birth',
-                payload: <String, Object?>{'setAt': bornAt},
-              );
-              await plane.session(workspace).offerOutcome(
-                domain: '__nomos_application_home_v1',
-                directiveId: 'nomosInternalSeedReceivingGroup7c1f5e',
-                actor: 'host-birth',
-                payload: <String, Object?>{
-                  'principal': owner,
-                  'workspaceName': _receivingGroupNameOf(owner),
-                  'bornAt': bornAt,
-                },
-              );
+              await plane.session(workspace).offerCallUsdaOutcome(
+                    call: applicationFrameworkCalls!.seedReceivingGroupPolicy(
+                      domain: '__nomos_application_home_v1',
+                      workspace: workspace,
+                      setAt: bornAt,
+                    ),
+                    actor: 'host-birth',
+                  );
+              await plane.session(workspace).offerCallUsdaOutcome(
+                    call: applicationFrameworkCalls.seedReceivingGroup(
+                      domain: '__nomos_application_home_v1',
+                      workspace: workspace,
+                      principal: owner,
+                      workspaceName: _receivingGroupNameOf(owner),
+                      bornAt: bornAt,
+                    ),
+                    actor: 'host-birth',
+                  );
             },
           );
           final parentCert = await plane.signBirthCert(
@@ -1798,14 +1888,9 @@ class NomosTestHarness {
                   _birthCertificateLawValue(delegationCert),
             },
           );
-          final enrollmentSync = await plane.sync(
+          await plane.sync(
             session: platformAuthorSession,
           );
-          if (enrollmentSync['ok'] == false) {
-            throw NomosTestHarnessException(
-              'cloudBound: sealed enrollFirstDevice offer did not converge: $enrollmentSync',
-            );
-          }
           return (
             publicB64: publicB64,
             secret: secret,
@@ -1868,27 +1953,24 @@ class NomosTestHarness {
           final birthSync = await plane.sync(
             session: '$clientId-platform-author',
           );
-          if (birthSync['pushFailed'] == true ||
-              birthSync['diverged'] == true ||
-              birthSync['stillAhead'] == true) {
+          if (birthSync.pushFailed ||
+              birthSync.diverged ||
+              birthSync.stillAhead) {
             throw NomosTestHarnessException(
               'cloudBound: the sealed receiving-group offer did not converge: $birthSync',
             );
           }
-          final remoteOutcomes =
-              ((birthSync['birthOutcomes'] as List?) ?? const [])
-                  .whereType<Map>()
-                  .map((entry) => entry.cast<String, Object?>())
-                  .toList();
+          final remoteOutcomes = birthSync.birthOutcomes;
           final failedRemoteBirth = remoteOutcomes.where(
             (entry) =>
-                entry['workspace']?.toString() == homeName &&
-                entry['status']?.toString() != 'born',
+                entry.hasWorkspace() &&
+                entry.workspace == homeName &&
+                entry.status != BirthOutcomeStatus.BIRTH_OUTCOME_STATUS_BORN,
           );
           if (failedRemoteBirth.isNotEmpty) {
             throw NomosTestHarnessException(
               'cloudBound: the remote parent replay refused the receiving-group birth: '
-              '${jsonEncode(failedRemoteBirth.toList())}',
+              '${failedRemoteBirth.toList()}',
             );
           }
           home = homeName;
@@ -1985,7 +2067,7 @@ class NomosTestHarness {
   /// each locally-born child's remote custody BEFORE that child's own sync converges against it. Repeats
   /// until every session reports neither `pushFailed` nor `stillAhead`, or [timeout] (then throws with the
   /// per-workspace last verdicts). Returns the final sync result per workspace.
-  Future<Map<String, Map<String, Object?>>> converge({
+  Future<Map<String, SyncWorkspaceResponse>> converge({
     Duration timeout = const Duration(seconds: 120),
     List<String>? workspaces,
   }) async {
@@ -1996,36 +2078,35 @@ class NomosTestHarness {
     final hw = homeWorkspace;
     if (hw != null && live.remove(hw)) live.insert(0, hw); // the parent leads
     final targets = workspaces ?? live;
-    final last = <String, Map<String, Object?>>{};
+    final last = <String, SyncWorkspaceResponse>{};
+    final lastErrors = <String, String>{};
     final pending = List.of(targets);
     final deadline = DateTime.now().add(timeout);
     while (pending.isNotEmpty) {
       for (final ws in List.of(pending)) {
         try {
-          final r = (await bridge.session(ws).sync(admit: true))
-              .cast<String, Object?>();
+          final r = await bridge.session(ws).sync(admit: true);
           last[ws] = r;
+          lastErrors.remove(ws);
           final permanentFailure = nmsPermanentConvergenceFailure(r);
           if (permanentFailure != null) {
             throw NomosTestHarnessException(
               'converge: $ws rejected or dead-lettered business work — $permanentFailure',
             );
           }
-          if (r['pushFailed'] != true &&
-              r['stillAhead'] != true &&
-              r['offline'] != true &&
-              r['deferred'] != true) pending.remove(ws);
+          if (!r.pushFailed && !r.stillAhead && !r.offline && r.deferred == 0)
+            pending.remove(ws);
         } on NomosTestHarnessException {
           rethrow;
         } catch (e) {
-          last[ws] = {'error': e.toString()};
+          lastErrors[ws] = e.toString();
         }
       }
       if (pending.isEmpty) break;
       if (DateTime.now().isAfter(deadline)) {
         throw NomosTestHarnessException(
           'converge: ${pending.length} workspace(s) did not converge within ${timeout.inSeconds}s — '
-          '${pending.map((w) => '$w: ${jsonEncode(last[w] ?? {})}').join('; ')}',
+          '${pending.map((w) => '$w: ${lastErrors[w] ?? last[w]?.toString() ?? "no result"}').join('; ')}',
         );
       }
       await Future<void>.delayed(const Duration(milliseconds: 500));