@githolon/dsl 0.108.7 → 0.110.1

package/dart/lib/src/session_bound.dart

@@ -6,7 +6,7 @@
 /// SESSION-BOUND CLIENTS (architecture/session_bound_clients.md) — the typed contract between a
 /// generated `<Domain>Client` and the [NomosSession] it is constructed with.
 ///
-/// THE FOUR-LAYER SPLIT: the ENGINE ([NomosBridge]/[NomosEngine]) is ONLY the multi-workspace
+/// THE FOUR-LAYER SPLIT: Reception is only the language-native multi-workspace
 /// runtime (mount/connect/session registry/sync/custody/follow-ref); a SESSION is exactly one
 /// workspace; a GENERATED CLIENT is exactly one session + one domain interface expectation + one
 /// actor context; everything else is a stateless value. This file carries:
@@ -20,17 +20,17 @@
 ///    the session's workspace does not serve the expected domain compatibly.
 ///  * [DomainNotInstalledForSession] — the context-rich replacement for the kernel's generic
 ///    "no active installed law declares domain 'x'" refusal, thrown wherever that error used to
-///    surface (bridge dispatch, birth lanes) with the full session context.
+///    surface (Reception dispatch, birth lanes) with the full session context.
 @internal
 library;
 
-import 'package:meta/meta.dart' show internal;
+import 'dart:typed_data';
 
-import 'dart:convert';
+import 'package:meta/meta.dart' show internal;
 
 import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
 
-import 'webview_bridge.dart';
+import 'reception/dart_reception.dart';
 
 /// The STATIC INTERFACE DESCRIPTOR a generated client exposes as `XClient.interface` — what the
 /// client EXPECTS of the workspace it binds to: the domain key, the law hash it was generated
@@ -42,29 +42,75 @@ class NomosClientInterface {
   /// sha256 of the `.package.usda` this client was generated against (advisory provenance).
   final String expectedDomainHash;
 
-  /// sha256 of the canonical structural interface JSON (from the baked compat manifest), when known.
-  final String? expectedInterfaceHash;
-
-  /// The structural interface (#72) as JSON — the directives + read shapes this client depends
-  /// on. Empty ⇒ no structural requirement was baked (hash-only provenance).
-  final String interfaceJson;
-
-  /// The compiler-baked compat manifest (§5) as JSON, when present — diagnosis only, never a gate.
-  final String? compatJson;
+  /// Canonical compiler-authored USDA compatibility matrix. The generated
+  /// client and Peer Office carry it opaquely; the kernel interprets it.
+  final Uint8List? compatibilityMatrixUsda;
 
   const NomosClientInterface({
     required this.domain,
     required this.expectedDomainHash,
-    this.expectedInterfaceHash,
-    this.interfaceJson = '',
-    this.compatJson,
+    this.compatibilityMatrixUsda,
+  });
+}
+
+/// The strongest remediation fact the local peer can prove without inventing
+/// a fleet policy decision that belongs to console.nomos.cafe.
+enum NomosCompatibilityGuidance {
+  none,
+  observeRemote,
+  workspaceUpdatePending,
+  controlPlaneDecisionRequired,
+}
+
+/// Exhaustive pre-dispatch posture for one exact generated operation.
+sealed class NomosOperationCompatibility {
+  const NomosOperationCompatibility({
+    required this.domain,
+    required this.directive,
   });
 
-  /// The `{domain: interface}` requirement map the shape-compat check consumes, or null when no
-  /// structural interface was baked.
-  Map<String, Object?>? get requirement => interfaceJson.isEmpty
-      ? null
-      : {domain: (jsonDecode(interfaceJson) as Map).cast<String, Object?>()};
+  final String domain;
+  final String directive;
+}
+
+final class NomosOperationAvailable extends NomosOperationCompatibility {
+  const NomosOperationAvailable({
+    required super.domain,
+    required super.directive,
+    required this.workspaceFrontier,
+  });
+
+  final String workspaceFrontier;
+}
+
+/// A generated write that the installed law cannot safely decode or execute.
+/// It is both a sealed posture value and the typed exception raised by
+/// [NomosSessionCompat.assertOperationCompatible].
+final class NomosOperationUnavailable extends NomosOperationCompatibility
+    implements Exception {
+  const NomosOperationUnavailable({
+    required super.domain,
+    required super.directive,
+    required this.guidance,
+    required this.differences,
+    required this.workspaceFrontier,
+  });
+
+  final NomosCompatibilityGuidance guidance;
+  final List<nomos_protocol.InterfaceMemberVerdict> differences;
+  final String workspaceFrontier;
+
+  @override
+  String toString() {
+    final detail = differences
+        .map((difference) => difference.diagnostic.isNotEmpty
+            ? difference.diagnostic
+            : '${difference.member}'
+                '${difference.field_4.isEmpty ? '' : '.${difference.field_4}'}')
+        .join('; ');
+    return 'NomosOperationUnavailable($domain/$directive, '
+        '${guidance.name}: ${detail.isEmpty ? 'not supported by installed law' : detail})';
+  }
 }
 
 /// The four distinguishable causes of a session/client mismatch (ask 9 of
@@ -136,11 +182,6 @@ class DomainClientSessionMismatch implements Exception {
     required this.hint,
   });
 
-  /// True only for the one bind failure a staged generated successor can
-  /// lawfully resolve by proving itself against this workspace's history.
-  bool get canAttemptGeneratedModelAdoption =>
-      cause == SessionMismatchCause.clientExpectsNewerInterface;
-
   @override
   String toString() =>
       'DomainClientSessionMismatch: session "${sessionId ?? '(unbound)'}" (workspace '
@@ -152,171 +193,9 @@ class DomainClientSessionMismatch implements Exception {
       'active law: ${activeDomainHashes.isEmpty ? '(unknown)' : activeDomainHashes.join(', ')})';
 }
 
-/// A generated candidate reached the lawful model-adoption boundary while
-/// binding, but exact-history proof requires a deliberate business decision or
-/// could not complete. The old model remains active and no compatibility
-/// fallback is used.
-enum DomainModelDifferenceKind { rules, outcome, evidence }
-
-final class DomainModelDifference {
-  final DomainModelDifferenceKind kind;
-  final String? area;
-  final String? action;
-  final String summary;
-
-  const DomainModelDifference({
-    required this.kind,
-    this.area,
-    this.action,
-    required this.summary,
-  });
-}
-
-final class DomainModelReview {
-  final int checkedActions;
-  final int candidateActions;
-  final bool? sameOutcome;
-  final List<DomainModelDifference> differences;
-
-  const DomainModelReview({
-    required this.checkedActions,
-    required this.candidateActions,
-    required this.sameOutcome,
-    required this.differences,
-  });
-}
-
-class DomainClientModelAdoptionRequired implements Exception {
-  final String expectedDomainKey;
-  final String expectedDomainHash;
-  final String status;
-  final String summary;
-  final DomainModelReview review;
-  final Future<void> Function()? _stage;
-  final Future<void> Function(String reason)? _accept;
-
-  const DomainClientModelAdoptionRequired({
-    required this.expectedDomainKey,
-    required this.expectedDomainHash,
-    required this.status,
-    required this.summary,
-    required this.review,
-    Future<void> Function()? stage,
-    Future<void> Function(String reason)? accept,
-  })  : _stage = stage,
-        _accept = accept;
-
-  bool get canStage => _stage != null;
-
-  Future<void> stage() {
-    final stage = _stage;
-    if (stage == null) {
-      throw StateError('This generated model is not waiting to be staged.');
-    }
-    return stage();
-  }
-
-  bool get canAccept => _accept != null;
-
-  /// Accept the candidate after reviewing the compiler-derived consequences.
-  /// Stable identities, retirements and value evolutions come from candidate
-  /// law; application code supplies accountability, never mechanical waivers.
-  Future<void> accept(String reason) {
-    final value = reason.trim();
-    if (value.isEmpty) {
-      throw ArgumentError.value(
-        reason,
-        'reason',
-        'must explain why changing prior business outcomes is intended',
-      );
-    }
-    final accept = _accept;
-    if (accept == null) {
-      throw StateError('This generated model change cannot be accepted.');
-    }
-    return accept(value);
-  }
-
-  @override
-  String toString() => 'DomainClientModelAdoptionRequired: generated model for '
-      '"$expectedDomainKey" ($expectedDomainHash) is $status. $summary';
-}
-
-/// A generated model step repeated without converging after several retries.
-///
-/// The limit is per immutable lifecycle step, not a cap on how many historical
-/// model generations a long-lived workspace may lawfully adopt. That distinction
-/// lets an old workspace catch up across an arbitrary backlog while still making
-/// a genuinely stuck stage/accept loop fail loudly and with useful context.
-final class DomainClientModelLifecycleStalled implements Exception {
-  const DomainClientModelLifecycleStalled({
-    required this.domain,
-    required this.candidateHash,
-    required this.status,
-    required this.attempts,
-  });
-
-  final String domain;
-  final String candidateHash;
-  final String status;
-  final int attempts;
-
-  @override
-  String toString() => 'DomainClientModelLifecycleStalled: generated model for '
-      '"$domain" ($candidateHash) remained $status after $attempts governed '
-      'attempts without progress.';
-}
-
-/// Converge every pending generated-model generation, bounded by repeated work.
-///
-/// A workspace can legitimately be more than a fixed number of generations
-/// behind. Each distinct domain/hash/status tuple is evidence of progress, so it
-/// gets its own retry budget. Only repetition of the same immutable step is a
-/// stall.
-Future<T> nmsInternalConvergeGeneratedModel<T>({
-  required Future<T> Function() attempt,
-  required Future<void> Function(DomainClientModelAdoptionRequired change)
-      handle,
-}) async {
-  const maxAttemptsPerStep = 12;
-  final attemptsByStep = <String, int>{};
-  while (true) {
-    try {
-      return await attempt();
-    } on DomainClientModelAdoptionRequired catch (change) {
-      // A lifecycle response with no lawful next action is a terminal refusal,
-      // not a convergence step. Preserve the kernel's exact diagnostic instead
-      // of retrying until a generic stall obscures it.
-      if (!change.canStage && !change.canAccept) throw change;
-      final step = '${change.expectedDomainKey}\u0000'
-          '${change.expectedDomainHash}\u0000'
-          '${change.status}\u0000'
-          '${change.canStage}\u0000${change.canAccept}';
-      final attempts = (attemptsByStep[step] ?? 0) + 1;
-      attemptsByStep[step] = attempts;
-      if (attempts > maxAttemptsPerStep) {
-        throw DomainClientModelLifecycleStalled(
-          domain: change.expectedDomainKey,
-          candidateHash: change.expectedDomainHash,
-          status: change.status,
-          attempts: attempts,
-        );
-      }
-      try {
-        await handle(change);
-      } on DomainClientModelAdoptionRequired catch (nextChange) {
-        // A transient preflight/acceptance race re-enters the same typed step.
-        // The per-step budget above prevents a genuine loop without limiting
-        // how many distinct historical generations may converge.
-        if (!nextChange.canStage && !nextChange.canAccept) throw nextChange;
-      }
-    }
-  }
-}
-
 /// The context-rich replacement for the kernel's generic
 /// `no active installed law declares domain 'x' … deploy the domain package first` refusal —
-/// thrown wherever that error used to surface (bridge dispatch, birth lanes) so an app dev sees
+/// thrown wherever that error used to surface (Reception dispatch, birth lanes) so an app dev sees
 /// WHICH session refused, what it actually runs, and the likely causes.
 class DomainNotInstalledForSession implements Exception {
   /// The domain key the dispatch named.
@@ -325,7 +204,7 @@ class DomainNotInstalledForSession implements Exception {
   /// The law hash the dispatch carried (advisory), when any.
   final String? expectedDomainHash;
 
-  /// The runner session the dispatch routed to (null on a bare single-session bridge).
+  /// The peer-office session the dispatch routed to.
   final String? sessionId;
 
   /// The workspace that session is pinned to.
@@ -383,47 +262,87 @@ class DomainNotInstalledForSession implements Exception {
 /// constructor, and directly from tests (ask 9). Throws [DomainClientSessionMismatch] with the
 /// cause classified; returns normally when the session serves the client's law compatibly.
 extension NomosSessionCompat on NomosSession {
+  /// Examine one exact generated write against the installed local law. The
+  /// session caches the kernel verdict until Peer Office reports a law/custody
+  /// change, so ordinary repeated writes perform no compatibility round-trip.
+  Future<NomosOperationCompatibility> operationCompatibility(
+    Uint8List applicationMatrixUsda, {
+    required String domain,
+    required String directive,
+  }) async {
+    final answer = await checkCompatibility(applicationMatrixUsda);
+    final failures = answer.examined.members
+        .where((member) =>
+            member.domain == domain &&
+            (member.kind ==
+                    nomos_protocol
+                        .InterfaceMemberKind.INTERFACE_MEMBER_KIND_DOMAIN ||
+                member.member == directive) &&
+            member.status !=
+                nomos_protocol.InterfaceCompatibilityStatus
+                    .INTERFACE_COMPATIBILITY_STATUS_EXACT &&
+            member.status !=
+                nomos_protocol.InterfaceCompatibilityStatus
+                    .INTERFACE_COMPATIBILITY_STATUS_COMPATIBLE)
+        .toList(growable: false);
+    if (failures.isEmpty) {
+      return NomosOperationAvailable(
+        domain: domain,
+        directive: directive,
+        workspaceFrontier: answer.examined.workspaceFrontier,
+      );
+    }
+    final guidance = switch (answer.localLawCurrency) {
+      nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_BEHIND =>
+        NomosCompatibilityGuidance.workspaceUpdatePending,
+      nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_CURRENT =>
+        NomosCompatibilityGuidance.controlPlaneDecisionRequired,
+      nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_UNOBSERVED ||
+      nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_UNSPECIFIED =>
+        NomosCompatibilityGuidance.observeRemote,
+      _ => NomosCompatibilityGuidance.observeRemote,
+    };
+    return NomosOperationUnavailable(
+      domain: domain,
+      directive: directive,
+      guidance: guidance,
+      differences: failures,
+      workspaceFrontier: answer.examined.workspaceFrontier,
+    );
+  }
+
+  Future<void> assertOperationCompatible(
+    Uint8List applicationMatrixUsda, {
+    required String domain,
+    required String directive,
+  }) async {
+    final posture = await operationCompatibility(
+      applicationMatrixUsda,
+      domain: domain,
+      directive: directive,
+    );
+    if (posture case final NomosOperationUnavailable unavailable) {
+      throw unavailable;
+    }
+  }
+
   Future<void> assertCompatible(NomosClientInterface iface) async {
-    // The exact generated package identity is stronger than a structural comparison. The kernel's
-    // point-readable `law/current.usda` answers this bounded happy path without materialising the
-    // complete interface offer. Structural discovery is reserved for genuine version skew.
     List<String> activeKeys = const [];
     List<String> activeHashes = const [];
-    try {
-      final law = await lawStatus(iface.expectedDomainHash);
-      activeHashes = ((law['current'] as List?) ?? const [])
-          .map((value) => value.toString())
-          .toList(growable: false);
-      if (activeHashes.contains(iface.expectedDomainHash)) return;
-      activeKeys = ((law['currentDomains'] as List?) ?? const [])
-          .map((value) => value.toString())
-          .toList(growable: false);
-      // Compatibility is member-scoped, not one enormous application-wide ceremony. Once the
-      // authenticated current-law index proves this domain is served, generated reads decode their
-      // exact USDA result types and generated offers are judged by the current kernel route. A new
-      // member therefore fails closed when used without blocking every older compatible feature.
-      if (activeKeys.contains(iface.domain)) return;
-    } catch (_) {
-      // Preserve the structural fallback for older kernels which do not expose the typed current
-      // frontier. Its error classification below remains the authoritative diagnostic path.
-    }
 
     // 1. THE SHAPE AXIS (#72) — the one compatibility notion. The kernel compares the
     // compact generated requirement directly with its authenticated current-law index. Do not
     // export/materialise the complete interface merely to prove the successful path.
-    final requirement = iface.requirement;
-    if (requirement == null) return;
-    Map<String, Object?> verdict;
+    final matrix = iface.compatibilityMatrixUsda;
+    if (matrix == null) return;
+    late nomos_protocol.InterfaceCompatibilityVerdict answer;
     try {
-      final raw = await checkCompatibility(requirement);
-      verdict = (raw['verdict'] is Map)
-          ? (raw['verdict'] as Map).cast<String, Object?>()
-          : raw;
+      answer = await checkCompatibility(matrix);
     } catch (e) {
       throw DomainClientSessionMismatch(
         expectedDomainKey: iface.domain,
         expectedDomainHash: iface.expectedDomainHash,
-        expectedInterfaceHash: iface.expectedInterfaceHash,
+        expectedInterfaceHash: null,
         sessionId: workspace,
         sessionWorkspace: workspace,
         activeDomainKeys: activeKeys,
@@ -431,101 +350,82 @@ extension NomosSessionCompat on NomosSession {
         hint: 'the shape-compatibility check itself failed: $e',
       );
     }
-    if (verdict['ok'] == true) return;
-
-    // 2. HASH DIAGNOSIS — only a failed verdict needs retained installation inventory.
-    if (iface.compatJson != null && iface.compatJson!.isNotEmpty) {
-      try {
-        final c = await checkCompat(
-            (jsonDecode(iface.compatJson!) as Map).cast<String, Object?>(),
-            iface.requirement);
-        if (c != null) activeHashes = c.workspaceRuns;
-      } catch (_) {
-        /* diagnosis only — never replace the shape verdict */
-      }
-    }
-
-    // 3. DIAGNOSTIC OFFER — only a failed verdict needs the complete active-domain names to
-    // distinguish a newer client from the wrong package or a genuinely absent deployment.
-    try {
-      final offer = await interfaceOffer();
-      if (offer != null) activeKeys = offer.keys.toList()..sort();
-    } catch (e) {
-      final isProjectionFault =
-          e.toString().contains('nomos.projection.read_failed') ||
-              e.toString().contains('projection read failed');
-      throw DomainClientSessionMismatch(
-        expectedDomainKey: iface.domain,
-        expectedDomainHash: iface.expectedDomainHash,
-        expectedInterfaceHash: iface.expectedInterfaceHash,
-        sessionId: workspace,
-        sessionWorkspace: workspace,
-        activeDomainHashes: activeHashes,
-        cause: isProjectionFault
-            ? SessionMismatchCause.projectionReadFailed
-            : null,
-        hint: isProjectionFault
-            ? 'the workspace law could NOT be READ — a projection/mount failure (NOT undeployed law): $e'
-            : 'the session workspace is not reachable/mounted on this plane: $e',
-      );
-    }
-
-    final missing =
-        ((verdict['missing'] as List?) ?? const []).map((e) => '$e').toList();
-    final incompatible = ((verdict['incompatible'] as List?) ?? const [])
-        .map((e) => '$e')
-        .toList();
+    final verdict = answer.examined;
+    if (verdict.compatible) return;
+
+    final failures = verdict.members
+        .where((member) =>
+            member.status ==
+                nomos_protocol.InterfaceCompatibilityStatus
+                    .INTERFACE_COMPATIBILITY_STATUS_UNAVAILABLE ||
+            member.status ==
+                nomos_protocol.InterfaceCompatibilityStatus
+                    .INTERFACE_COMPATIBILITY_STATUS_INCOMPATIBLE)
+        .toList(growable: false);
+    final missing = failures
+        .where((member) =>
+            member.status ==
+            nomos_protocol.InterfaceCompatibilityStatus
+                .INTERFACE_COMPATIBILITY_STATUS_UNAVAILABLE)
+        .map((member) => member.field_4.isEmpty
+            ? '${member.domain}/${member.member}'
+            : '${member.domain}/${member.member}/${member.field_4}')
+        .toList(growable: false);
+    final incompatible = failures
+        .where((member) =>
+            member.status ==
+            nomos_protocol.InterfaceCompatibilityStatus
+                .INTERFACE_COMPATIBILITY_STATUS_INCOMPATIBLE)
+        .map((member) => member.diagnostic.isEmpty
+            ? '${member.domain}/${member.member}'
+            : member.diagnostic)
+        .toList(growable: false);
+    final domainMissing = failures.any((member) =>
+        member.reason ==
+        nomos_protocol.InterfaceCompatibilityReason
+            .INTERFACE_COMPATIBILITY_REASON_DOMAIN_MISSING);
 
     // 4. CLASSIFY the four causes (ask 9).
     SessionMismatchCause cause;
     String hint;
-    if (nmsInternalClientExpectsNewerInterface(
-      domain: iface.domain,
-      activeDomainKeys: activeKeys,
-      missing: missing,
-      incompatible: incompatible,
-    )) {
+    if (!domainMissing) {
       cause = SessionMismatchCause.clientExpectsNewerInterface;
       final differences = [...incompatible, ...missing];
       hint =
           'the domain is installed but type-divergent from what this client requires '
           '(${differences.join('; ')}) — recompile the client against the deployed law, or evolve the law';
-    } else if (activeKeys.isNotEmpty && !activeKeys.contains(iface.domain)) {
-      cause = SessionMismatchCause.wrongPackageMounted;
-      hint =
-          'this workspace runs a DIFFERENT package (${activeKeys.join(', ')}) — '
-          'bind this client to the session whose workspace holds "${iface.domain}"';
     } else {
-      // The domain (or its whole offer) is absent here. Stale-vs-never-deployed: if this session is
-      // cloud-bound and behind, a sync may bring the law; otherwise it was never deployed.
-      var behind = 0;
-      var cloudBound = false;
-      try {
-        final m = await metrics();
-        behind = ((m['behind'] as num?) ?? 0).toInt();
-        final listed = await listWorkspaces();
-        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;
-        hint =
-            'local custody is $behind commit(s) behind its cloud — sync/pull, then re-bind '
-            '(missing: ${missing.join('; ')})';
-      } else {
-        cause = SessionMismatchCause.trulyNotDeployed;
-        hint =
-            'no installed law on this workspace declares "${iface.domain}" — '
-            'deploy the domain package first (missing: ${missing.join('; ')})';
+      // The domain (or its whole offer) is absent here. Stale-vs-never-deployed is
+      // a CORRESPONDENCE fact, and THE OFFICE STATES IT. Reception used to guess by
+      // reading a `SyncStatus.behind` count the reducer only ever set to 0 or null,
+      // so the "stale" arm was unreachable and every absence read as "never
+      // deployed". The desk's verdict now names the currency; this renders it.
+      switch (answer.localLawCurrency) {
+        case nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_BEHIND:
+          cause = SessionMismatchCause.liveCloudHasLawButLocalStale;
+          hint =
+              'local custody trails its remote frontier — sync, then re-bind '
+              '(missing: ${missing.join('; ')})';
+          break;
+        case nomos_protocol.LocalLawCurrency.LOCAL_LAW_CURRENCY_UNOBSERVED:
+          cause = SessionMismatchCause.liveCloudHasLawButLocalStale;
+          hint =
+              'no installed law on this workspace declares "${iface.domain}", and no '
+              'remote frontier has been observed, so it may yet arrive — sync and '
+              're-bind; if it still refuses, deploy the domain package '
+              '(missing: ${missing.join('; ')})';
+          break;
+        default:
+          cause = SessionMismatchCause.trulyNotDeployed;
+          hint =
+              'no installed law on this workspace declares "${iface.domain}" — '
+              'deploy the domain package first (missing: ${missing.join('; ')})';
       }
     }
     throw DomainClientSessionMismatch(
       expectedDomainKey: iface.domain,
       expectedDomainHash: iface.expectedDomainHash,
-      expectedInterfaceHash: iface.expectedInterfaceHash,
+      expectedInterfaceHash: null,
       sessionId: workspace,
       sessionWorkspace: workspace,
       activeDomainKeys: activeKeys,
@@ -535,14 +435,3 @@ extension NomosSessionCompat on NomosSession {
     );
   }
 }
-
-/// Generator/runtime classification seam. A required member missing from an
-/// already installed domain is a newer-client shape, not an absent deployment.
-bool nmsInternalClientExpectsNewerInterface({
-  required String domain,
-  required List<String> activeDomainKeys,
-  required List<String> missing,
-  required List<String> incompatible,
-}) =>
-    incompatible.isNotEmpty ||
-    (missing.isNotEmpty && activeDomainKeys.contains(domain));