@githolon/dsl 0.113.4 → 0.115.0

package/dart_types/lib/src/approved_model.dart

@@ -12,23 +12,82 @@ import 'dart:typed_data';
 
 final RegExp _lowerHex64 = RegExp(r'^[0-9a-f]{64}$');
 
+/// ONE APPLICATION DOMAIN'S REQUIREMENT (CAP-666), as the compiler generated it
+/// beside the unit set: the exact law unit the client was compiled against
+/// (`domain:<key>` in `build/<name>.units`) and the identity of the generated
+/// consumer requirement for that domain (the domain's slice of
+/// `<name>.compatibility.usda`, which the kernel's Compatibility Desk judges).
+///
+/// A workspace serving exactly [unitSha256] for [domainKey] satisfies this
+/// release for that domain even when its unit set carries other domains the
+/// application never touches. Identities only; the bytes stay in the generated
+/// client. Const-constructible so generated code can bake it; the approved
+/// model validates it.
+final class NomosDomainRequirement {
+  const NomosDomainRequirement({
+    required this.domainKey,
+    required this.unitSha256,
+    required this.requirementSha256,
+  });
+
+  /// The application domain key this requirement is about.
+  final String domainKey;
+
+  /// The hash of the domain's law unit (`domain:<key>`), 64 lowercase hex.
+  final String unitSha256;
+
+  /// The sha256 of the domain's generated compatibility requirement, 64
+  /// lowercase hex. Observation and qualification name the contract by it.
+  final String requirementSha256;
+
+  /// The wire shape the inventory carries (identities only).
+  Map<String, String> toJson() => {
+        'unit': unitSha256,
+        'requirement': requirementSha256,
+      };
+
+  @override
+  bool operator ==(Object other) =>
+      other is NomosDomainRequirement &&
+      other.domainKey == domainKey &&
+      other.unitSha256 == unitSha256 &&
+      other.requirementSha256 == requirementSha256;
+
+  @override
+  int get hashCode => Object.hash(domainKey, unitSha256, requirementSha256);
+
+  @override
+  String toString() =>
+      'NomosDomainRequirement($domainKey: unit $unitSha256, requirement $requirementSha256)';
+}
+
 /// The law model an application release approves, supplied once at the
 /// application's Reception. Every field is required: the office refuses to
-/// adopt without the package identity, the domain keys it observes, the
-/// attributed reason the kernel's transition demands, or the package bytes a
-/// child must stage — none of them can be invented later.
+/// adopt without the law (its unit set), the package identity, the domain keys
+/// it observes, the attributed reason the kernel's transition demands, or the
+/// package bytes a child must stage — none of them can be invented later.
 final class NomosApprovedModel {
   NomosApprovedModel({
+    required this.unitSet,
     required this.lawSha256,
     required this.reason,
     required List<String> domainKeys,
     required this.loadPackage,
-  }) : domainKeys = List.unmodifiable(domainKeys) {
+    Map<String, NomosDomainRequirement> domainRequirements = const {},
+  })  : domainKeys = List.unmodifiable(domainKeys),
+        domainRequirements = Map.unmodifiable(domainRequirements) {
+    if (!_lowerHex64.hasMatch(unitSet)) {
+      throw ArgumentError.value(
+        unitSet,
+        'unitSet',
+        'must be the unit set identity of the compiled build/<name>.units (64 lowercase hex)',
+      );
+    }
     if (!_lowerHex64.hasMatch(lawSha256)) {
       throw ArgumentError.value(
         lawSha256,
         'lawSha256',
-        'must be the kernel-derived identity of the compiled law package (64 lowercase hex)',
+        'must be the identity of the compiled package closure (64 lowercase hex)',
       );
     }
     if (reason.trim().isEmpty) {
@@ -46,9 +105,36 @@ final class NomosApprovedModel {
         'must name the application domain keys the office observes on each workspace',
       );
     }
+    for (final entry in this.domainRequirements.entries) {
+      final requirement = entry.value;
+      if (entry.key.trim().isEmpty || requirement.domainKey != entry.key) {
+        throw ArgumentError.value(
+          domainRequirements,
+          'domainRequirements',
+          'must be keyed by the domain key each requirement names',
+        );
+      }
+      if (!_lowerHex64.hasMatch(requirement.unitSha256) ||
+          !_lowerHex64.hasMatch(requirement.requirementSha256)) {
+        throw ArgumentError.value(
+          requirement,
+          'domainRequirements',
+          "'${entry.key}' must carry the generated domain unit hash and requirement identity (64 lowercase hex each)",
+        );
+      }
+    }
   }
 
-  /// The kernel-derived identity of the compiled `.law.usdz` closure.
+  /// THE LAW this release approves (CAP-773): the unit set identity of the
+  /// compiled `build/<name>.units` (the generated `frameworkCalls.lawUnitSet`).
+  /// A workspace is on it when the closure it serves is composed from exactly
+  /// these units, whatever its kernel's composer.
+  final String unitSet;
+
+  /// The compiled package closure (`.law.usdz`, the generated
+  /// `frameworkCalls.lawPackageSha256`): the bytes [loadPackage] supplies when a
+  /// package-lane workspace must stage them. Package — not what a unit-lane
+  /// workspace serves.
   final String lawSha256;
 
   /// The attributed approval text. The kernel's transition demands it whenever
@@ -59,6 +145,14 @@ final class NomosApprovedModel {
   /// alone; keys it does not serve are ignored.
   final List<String> domainKeys;
 
+  /// THE PER-DOMAIN REQUIREMENTS this release was generated against (CAP-666):
+  /// the generated `frameworkCalls.domainRequirements`, by domain key. A served
+  /// key whose workspace serves exactly that domain unit is current for this
+  /// release whatever else its unit set carries; the office reports them and
+  /// the client inventory records them as this build's contract. Empty on a
+  /// client generated before they existed: [unitSet] alone then decides.
+  final Map<String, NomosDomainRequirement> domainRequirements;
+
   /// The exact compiled package bytes, read only when a workspace must stage
   /// them (a bundled asset, a file beside the generated facade).
   final Future<Uint8List> Function() loadPackage;