@githolon/dsl 0.113.4 → 0.115.0

package/dart/test/receiving_group_open_test.dart

@@ -14,7 +14,6 @@ const _principal = 'user:ada';
 // The office names the receiving group; Reception asks for it. A test scripts
 // that answer like any other paper.
 const _group = 'nomos-rg-scripted';
-final _lawSha256 = '2' * 64;
 
 final class _Office implements PeerOfficeConnection {
   _Office({this.refuse});
@@ -88,7 +87,7 @@ Future<DartReception> _connected(_Office office) async {
 
 void main() {
   test(
-      'the session sends exactly one open paper: contract, principal, session, no seed',
+      'the session sends exactly one open paper: principal, session, no seed',
       () async {
     final office = _Office();
     final reception = await _connected(office);
@@ -97,7 +96,6 @@ void main() {
           application: 'acme-platform',
           principal: _principal,
           authToken: 'id-token',
-          contract: protocol.ApplicationBirthContract(lawSha256: _lawSha256),
           verifyHistory: true,
         );
 
@@ -109,10 +107,9 @@ void main() {
     expect(paper.application, 'acme-platform');
     expect(paper.principal, _principal);
     expect(utf8.decode(paper.authToken), 'id-token');
-    expect(paper.contract.lawSha256, _lawSha256);
-    expect(paper.contract.toProto3Json(), {'lawSha256': _lawSha256},
+    expect((paper.toProto3Json()! as Map).keys, isNot(contains('contract')),
         reason:
-            'the contract is law-only: the platform controller is observed by the desk');
+            'no compiled law rides the paper: the Home takes what its platform serves (CAP-773)');
     expect(paper.genesisSeed, isEmpty, reason: 'seeds are law');
     expect(paper.verifyHistory, isTrue);
     expect(papers.single.protocolVersion, 2);
@@ -137,8 +134,7 @@ void main() {
             application: 'acme-platform',
             principal: _principal,
             authToken: 'id-token',
-            contract: protocol.ApplicationBirthContract(lawSha256: _lawSha256),
-          ),
+            ),
       throwsA(isA<NomosRuntimeError>().having(
         (e) => e.info.code,
         'code',

package/dart/test/replica_readiness_test.dart

@@ -128,15 +128,20 @@ void main() {
 
   // The guard: every one-shot read reaches the kernel through one of these two
   // request shapes. Each must sit inside nmsUntilReplicaReady, so a new read
-  // path cannot hand callers a "not ready yet" as an error.
+  // path cannot hand callers a "not ready yet" as an error. A site is where the
+  // request is BUILT (its requestId, or the historic request), never a trace line
+  // that merely names the same logical id (CAP-741's `call.send`), and "inside"
+  // means the readiness wait opens between the site's enclosing member and the
+  // site, however much tracing the closure carries.
   test('every kernel query request is built inside nmsUntilReplicaReady', () {
     final source = File(
       'lib/src/reception/dart_reception.dart',
     ).readAsLinesSync();
+    final member = RegExp(r'^  [A-Za-z_]');
     final requestSites = <int>[];
     for (var i = 0; i < source.length; i++) {
       final line = source[i];
-      if (line.contains(r":query:$") ||
+      if ((line.contains('requestId:') && line.contains(r":query:$")) ||
           line.contains(
               'historicQuery: nomos_protocol.HistoricQueryRequest(')) {
         requestSites.add(i);
@@ -144,9 +149,14 @@ void main() {
     }
     expect(requestSites, hasLength(2), reason: 'query request sites moved');
     for (final site in requestSites) {
-      final window = source.sublist(site - 16 < 0 ? 0 : site - 16, site);
+      var start = site;
+      while (start > 0 && !member.hasMatch(source[start])) {
+        start--;
+      }
       expect(
-        window.any((line) => line.contains('nmsUntilReplicaReady(')),
+        source
+            .sublist(start, site)
+            .any((line) => line.contains('nmsUntilReplicaReady(')),
         isTrue,
         reason: 'dart_reception.dart:${site + 1} sends a kernel query outside '
             'nmsUntilReplicaReady',

package/dart/test/rows_watch_test.dart

@@ -0,0 +1,331 @@
+import 'dart:async';
+import 'dart:convert';
+
+import 'package:nomos_client/src/generated_call.dart' show NmsGeneratedResult;
+import 'package:nomos_client/src/rows_watch.dart';
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+import 'package:nomos_types/src/proto/google/protobuf/any.pb.dart'
+    as google_protobuf;
+import 'package:test/test.dart';
+
+const _type = 'type.nomos.dev/nomos.operation.v1.QueryResult_q';
+
+/// A generated row stand-in: value equality like the generated models, so
+/// identity is observable separately.
+final class Row {
+  Row(this.id, this.value);
+  final String id;
+  final int value;
+  @override
+  bool operator ==(Object other) =>
+      other is Row && other.id == id && other.value == value;
+  @override
+  int get hashCode => Object.hash(id, value);
+  @override
+  String toString() => '$id=$value';
+}
+
+/// The test's "generated decoder": `id=value` pairs separated by `;`.
+List<Row> _decode(NmsGeneratedResult result) {
+  expect(result.protobufType, _type);
+  final text = utf8.decode(result.protobufPayload);
+  if (text.isEmpty) return const [];
+  return [
+    for (final pair in text.split(';'))
+      Row(pair.split('=')[0], int.parse(pair.split('=')[1])),
+  ];
+}
+
+google_protobuf.Any _rows(Map<String, int> rows) => google_protobuf.Any(
+      typeUrl: _type,
+      value:
+          utf8.encode(rows.entries.map((e) => '${e.key}=${e.value}').join(';')),
+    );
+
+nomos_protocol.WatchChanged _full(String frontier, Map<String, int> rows) =>
+    nomos_protocol.WatchChanged(
+      subscriptionId: 'w',
+      applicationResult: _rows(rows),
+      resultFrontier: frontier,
+    );
+
+nomos_protocol.WatchChanged _delta(
+  String base,
+  String frontier,
+  Map<String, int> rows, [
+  List<String> removed = const [],
+]) =>
+    nomos_protocol.WatchChanged(
+      subscriptionId: 'w',
+      applicationDelta: nomos_protocol.ApplicationResultDelta(
+        baseFrontier: base,
+        frontier: frontier,
+        changedRows: _rows(rows),
+        removedIds: removed,
+      ),
+    );
+
+NmsRowsMerge<Row> _merge() =>
+    NmsRowsMerge<Row>(decode: _decode, idOf: (row) => row.id);
+
+void main() {
+  test(
+      'a delta patches the complete result in id order; untouched rows keep identity',
+      () {
+    final merge = _merge();
+    final first = merge.apply(_full('f1', {'b': 2, 'a': 1, 'c': 3}))!;
+    expect(first.map((row) => row.id), ['a', 'b', 'c']);
+
+    final second = merge.apply(_delta('f1', 'f2', {'b': 20, 'd': 4}, ['c']))!;
+    expect(second, [Row('a', 1), Row('b', 20), Row('d', 4)]);
+    expect(identical(second[0], first[0]), isTrue,
+        reason: 'row a was not touched');
+
+    // A changed row that decodes equal keeps the held object and emits nothing.
+    expect(merge.apply(_delta('f2', 'f3', {'a': 1})), isNull);
+    final third = merge.apply(_delta('f3', 'f4', {'e': 5}))!;
+    expect(identical(third[0], first[0]), isTrue);
+  });
+
+  test(
+      'a complete result equal to the held rows emits nothing and keeps identity',
+      () {
+    final merge = _merge();
+    final first = merge.apply(_full('f1', {'a': 1, 'b': 2}))!;
+    expect(merge.apply(_full('f2', {'a': 1, 'b': 2})), isNull);
+    final next = merge.apply(_full('f3', {'a': 1, 'b': 3}))!;
+    expect(identical(next[0], first[0]), isTrue);
+    expect(next[1], Row('b', 3));
+    // Fewer rows is a change even when every remaining row is equal.
+    expect(merge.apply(_full('f4', {'a': 1})), [Row('a', 1)]);
+    // The position moved with the complete result.
+    expect(merge.apply(_delta('f4', 'f5', {'z': 26})),
+        [Row('a', 1), Row('z', 26)]);
+  });
+
+  test('ids order by code point, as the kernel orders them', () {
+    final merge = _merge();
+    final ids = ['\u{1F600}', '～', 'a', 'B'];
+    final rows = merge.apply(_full('f1', {for (final id in ids) id: 0}))!;
+    expect(rows.map((row) => row.id), ['B', 'a', '～', '\u{1F600}']);
+    expect(compareCodePoints('～', '\u{1F600}'), lessThan(0));
+    expect('～'.compareTo('\u{1F600}'), greaterThan(0),
+        reason: 'UTF-16 order differs, which is why the merge does not use it');
+  });
+
+  test('a delta from another position ends the watch with a typed error',
+      () async {
+    final source = StreamController<nomos_protocol.WatchChanged>();
+    final events = <Object>[];
+    final done = Completer<void>();
+    nmsMergeRows(source.stream, _merge()).listen(
+      events.add,
+      onError: events.add,
+      onDone: done.complete,
+    );
+    source.add(_full('f1', {'a': 1}));
+    source.add(_delta('elsewhere', 'f2', {'a': 2}));
+    await done.future;
+    expect(events, hasLength(2));
+    final mismatch = events[1] as NomosWatchPositionMismatch;
+    expect(mismatch.held, 'f1');
+    expect(mismatch.base, 'elsewhere');
+    expect(source.hasListener, isFalse,
+        reason: 'the peer subscription is released');
+  });
+
+  test(
+      'a delivered failure resets the rows; only a complete result restores them',
+      () async {
+    final source = StreamController<nomos_protocol.WatchChanged>();
+    final events = <Object>[];
+    final done = Completer<void>();
+    nmsMergeRows(source.stream, _merge()).listen(
+      events.add,
+      onError: events.add,
+      onDone: done.complete,
+    );
+    source.add(_full('f1', {'a': 1}));
+    source.addError(StateError('kernel unavailable'));
+    source.add(_full('f2', {'a': 1}));
+    source.add(_delta('f2', 'f3', {'b': 2}));
+    await source.close();
+    await done.future;
+    expect(events[0], [Row('a', 1)]);
+    expect(events[1], isA<StateError>());
+    expect(events[2], [Row('a', 1)],
+        reason: 'after a failure the complete rows are delivered again');
+    expect(events[3], [Row('a', 1), Row('b', 2)]);
+
+    // Without a complete result after the failure, a delta has no position.
+    final merge = _merge()..apply(_full('f1', {'a': 1}));
+    merge.reset();
+    expect(() => merge.apply(_delta('f1', 'f2', {})),
+        throwsA(isA<NomosWatchPositionMismatch>()));
+  });
+
+  test('each emission names the rows it changed and removed (CAP-751)', () {
+    final merge = _merge();
+    final first = merge.apply(_full('f1', {'a': 1, 'b': 2, 'c': 3}))!;
+    expect(first.complete, isTrue);
+    expect(first.changedIds, {'a', 'b', 'c'});
+    expect(first.removedIds, isEmpty);
+
+    final second = merge.apply(_delta('f1', 'f2', {'b': 20, 'd': 4}, ['c']))!;
+    expect(second.complete, isFalse);
+    expect(second.changedIds, {'b', 'd'});
+    expect(second.removedIds, {'c'});
+    for (final row in second) {
+      if (!second.changedIds.contains(row.id)) {
+        expect(first.contains(row), isTrue);
+        expect(identical(row, first.firstWhere((r) => r.id == row.id)), isTrue,
+            reason: 'a row outside changedIds is the object emitted before');
+      }
+    }
+
+    // Removed and re-added in one delta is a replacement.
+    final third = merge.apply(_delta('f2', 'f3', {'a': 10}, ['a']))!;
+    expect(third.changedIds, {'a'});
+    expect(third.removedIds, isEmpty);
+
+    // A complete result reports exactly what differs from the held rows.
+    final fourth = merge.apply(_full('f4', {'a': 10, 'b': 20, 'e': 5}))!;
+    expect(fourth.complete, isTrue);
+    expect(fourth.changedIds, {'e'});
+    expect(fourth.removedIds, {'d'});
+    expect(() => (fourth as List<Row>).add(Row('x', 0)),
+        throwsUnsupportedError);
+  });
+
+  group('NomosRowProjection', () {
+    test('projects only rows it has not seen, keeping earlier projections', () {
+      final merge = _merge();
+      var calls = 0;
+      final projection = NomosRowProjection<Row, String>((row) {
+        calls += 1;
+        return '${row.id}:${row.value}';
+      });
+      final first = projection.apply(merge.apply(_full('f1', {
+        for (var i = 0; i < 100; i += 1) 'r${i.toString().padLeft(3, '0')}': i,
+      }))!);
+      expect(calls, 100);
+      final second =
+          projection.apply(merge.apply(_delta('f1', 'f2', {'r050': -1}))!);
+      expect(calls, 101, reason: 'one changed row, one projection');
+      expect(second[50], 'r050:-1');
+      expect(identical(second[49], first[49]), isTrue);
+      expect(second.length, 100);
+      // The same rows again: the identical output.
+      final rows = merge.apply(_delta('f2', 'f3', {'r999': 9}))!;
+      final third = projection.apply(rows);
+      expect(identical(projection.apply(rows), third), isTrue);
+      expect(calls, 102);
+    });
+
+    test('an order is kept by merging new projections into the previous order',
+        () {
+      final merge = _merge();
+      var calls = 0;
+      int byValueThenId(Row a, Row b) {
+        final byValue = a.value.compareTo(b.value);
+        return byValue != 0 ? byValue : a.id.compareTo(b.id);
+      }
+
+      final projection = NomosRowProjection<Row, Row>((row) {
+        calls += 1;
+        return row.value < 0 ? null : row; // negative values are left out
+      }, order: byValueThenId);
+      final values = {for (var i = 0; i < 50; i += 1) 'r$i': (i * 37) % 50};
+      final first = projection.apply(merge.apply(_full('f1', values))!);
+      expect(first, [...first]..sort(byValueThenId));
+      expect(first.length, 50);
+
+      var frontier = 1;
+      List<Row> step(Map<String, int> rows, [List<String> removed = const []]) {
+        final emitted =
+            merge.apply(_delta('f$frontier', 'f${frontier + 1}', rows, removed))!;
+        frontier += 1;
+        return projection.apply(emitted);
+      }
+
+      var out = step({'r3': 1000, 'r7': -5, 'new': 25}, ['r9']);
+      final expected = [
+        for (final row in _merge().apply(_full('check', {
+          for (final e in values.entries)
+            if (e.key != 'r9') e.key: e.value,
+          'r3': 1000,
+          'r7': -5,
+          'new': 25,
+        }))!)
+          if (row.value >= 0) row,
+      ]..sort(byValueThenId);
+      expect(out, expected);
+      expect(calls, 53, reason: 'only the three rows the delta carried');
+
+      // Leaving a row out anew changes the output; filtering it again does not.
+      out = step({'r7': -6});
+      expect(out, expected);
+      calls = 0;
+      projection.invalidate();
+      expect(projection.apply(out), expected);
+      expect(calls, expected.length);
+    });
+
+    test('projectRows forwards only changed outputs, one projection per listener',
+        () async {
+      final source = StreamController<List<Row>>.broadcast(sync: true);
+      var calls = 0;
+      final projected = source.stream.projectRows<String>((row) {
+        calls += 1;
+        return row.value.isEven ? row.id : null;
+      });
+      final a = <List<String>>[];
+      final b = <List<String>>[];
+      final subA = projected.listen(a.add);
+      final subB = projected.listen(b.add);
+      final r1 = Row('a', 2);
+      final r2 = Row('b', 3);
+      source.add([r1, r2]);
+      source.add([r1, r2]); // identical rows: nothing new to forward
+      source.add([r1, Row('b', 4)]);
+      await pumpEventQueue();
+      expect(a, [
+        ['a'],
+        ['a', 'b'],
+      ]);
+      expect(b, a);
+      expect(calls, 6, reason: 'two listeners, three distinct rows each');
+      await subA.cancel();
+      await subB.cancel();
+      await source.close();
+    });
+
+    test('a thousand rows and single-row deltas cost one projection per delta',
+        () async {
+      final source = StreamController<nomos_protocol.WatchChanged>();
+      var calls = 0;
+      final outputs = <List<String>>[];
+      final sub = nmsMergeRows(source.stream, _merge())
+          .projectRows<String>((row) {
+        calls += 1;
+        return 'p${row.value}';
+      }, order: (x, y) => x.compareTo(y)).listen(outputs.add);
+      source.add(_full('f0', {
+        for (var i = 0; i < 1000; i += 1) 'r${i.toString().padLeft(4, '0')}': i,
+      }));
+      for (var i = 0; i < 50; i += 1) {
+        source.add(_delta('f$i', 'f${i + 1}',
+            {'r${(i * 7).toString().padLeft(4, '0')}': 10000 + i}));
+      }
+      await pumpEventQueue();
+      expect(outputs, hasLength(51));
+      expect(calls, 1000 + 50);
+      final last = outputs.last;
+      expect(last, [...last]..sort());
+      expect(last.length, 1000);
+      await sub.cancel();
+      await source.close();
+    });
+  });
+}
+

package/dart/test/runtime_projections_test.dart

@@ -61,6 +61,47 @@ void main() {
     expect(receipt.current.phase, NomosOperationPhase.converged);
   });
 
+  test(
+      'a birth custody refused as already parented fails its creation receipt, '
+      'typed and terminal (CAP-804)', () async {
+    final projection = NmsOperationReceiptProjection();
+    final birth = projection.register('home-bob', 'intent-birth');
+    projection.rememberBirth('notebook-1', birth);
+    final other = projection.register('home-bob', 'intent-other');
+    projection.advance(
+      'home-bob',
+      protocol.SyncWorkspaceResponse(
+        pushFailed: true,
+        admittedIntentIds: const ['intent-other'],
+        birthOutcomes: [
+          protocol.BirthOutcome(
+            workspace: 'notebook-1',
+            childWorkspace: 'notebook-1',
+            parentWorkspace: 'home-bob',
+            status: protocol.BirthOutcomeStatus.BIRTH_OUTCOME_STATUS_REFUSED,
+            code: 'birth-child-already-parented',
+            refusal: protocol.KernelRefusal(
+              terminal: true,
+              message: "[birth-child-already-parented] workspace 'notebook-1' "
+                  'already has a parent',
+            ),
+          ),
+        ],
+      ),
+    );
+    await expectLater(
+      birth.admitted,
+      throwsA(isA<NomosOperationRefused>()
+          .having((r) => r.code, 'code', 'birth-child-already-parented')
+          .having((r) => r.childWorkspace, 'child', 'notebook-1')),
+    );
+    await expectLater(birth.converged, throwsA(isA<NomosOperationRefused>()));
+    expect(birth.current.isRefused, isTrue);
+    expect(birth.current.phase, NomosOperationPhase.locallyAccepted);
+    // The parent's other write in the same round is unaffected.
+    await other.admitted;
+  });
+
   test('typed watch registry only correlates runtime events and cancellation',
       () async {
     final registry = NmsTypedWatchRegistry();

package/dart/test/test_peer_host_selection_test.dart

@@ -0,0 +1,49 @@
+// The canonical test peer's host is DECLARED by NOMOS_TEST_PEER_HOST: unset/node is the Node
+// peer, native is the Apple native host the caller registered. A value naming no host, or native
+// selected without a registered host, is refused loudly — never quietly run on Node.
+@TestOn('vm')
+library;
+
+import 'package:nomos_client/src/testing/test_peer_host.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('unset or node selects the Node peer', () {
+    expect(NmsTestPeerHostKind.selected(const {}), NmsTestPeerHostKind.node);
+    expect(
+      NmsTestPeerHostKind.selected(const {nmsTestPeerHostVariable: 'node'}),
+      NmsTestPeerHostKind.node,
+    );
+  });
+
+  test('native selects the Apple native host', () {
+    expect(
+      NmsTestPeerHostKind.selected(const {nmsTestPeerHostVariable: 'native'}),
+      NmsTestPeerHostKind.native,
+    );
+  });
+
+  test('a value naming no host is refused, not defaulted to Node', () {
+    expect(
+      () => NmsTestPeerHostKind.selected(
+          const {nmsTestPeerHostVariable: 'nativ'}),
+      throwsA(isA<StateError>().having(
+        (error) => error.message,
+        'message',
+        contains('names no test peer host'),
+      )),
+    );
+  });
+
+  test('native selected without a registered host is refused with the remedy',
+      () {
+    expect(
+      NmsTestPeerHosts.requireNative,
+      throwsA(isA<StateError>().having(
+        (error) => error.message,
+        'message',
+        contains('registerNomosNativeTestPeerHost()'),
+      )),
+    );
+  });
+}

package/dart_types/CHANGELOG.md

@@ -1,3 +1,42 @@
+## 0.14.0
+
+- Live stream frames for peer catch-up (CAP-826): `LiveOfferFrame` gains checkpoint, history, ref, pack and
+  refusal frames; `PeerStreamEffect`/`PeerStreamReceipt`; the runtime command `serveLiveStream`; and the kernel's
+  shallow pack request (`PackDeltaRequest.depth`, `below_head`, `also_heads`).
+
+- `NomosDomainRequirement` and `NomosApprovedModel.domainRequirements` (CAP-666): per application domain key,
+  the exact law unit (`domain:<key>` of the unit set) and the generated consumer requirement identity a client
+  was compiled against. A workspace serving that unit for the key is current for the release whatever else its
+  unit set carries. `AdoptApplicationModelRequest` carries them as `domain_requirements` (field 7,
+  `DomainUnitRequirement`). Empty on clients generated before they existed: `unitSet` alone then decides.
+- `KeyedBirthName.parent` (field 3) is reserved and unused (CAP-803): a business child is named by namespace and
+  key, fixed at birth. CAP-788's parent-scoped naming is withdrawn before release; one parent per node is the
+  kernel's `[birth-child-already-parented]` refusal.
+- Carry the current generated kernel Protobuf contract: `FrontierTransitionRequest.candidateUnits`,
+  `InterfaceCompatibilityQuery.candidateUnits` and `InterfaceCompatibilityResponse.candidateHash` qualify a law
+  release without installing it (CAP-789).
+  `ApplyPackRequest.work_budget_bytes` / `continue_pending` and `ApplyPackResponse.import_pending` /
+  `work_done_bytes` import a pack in bounded steps (CAP-806). `LawIdentity`, `LawVersion`, `LawVersionClaim` and
+  `OfferAdmitted.law_version_warnings` (`LawVersionWarning`, `LawVersionOrder`) report an install that does not
+  move its law's claimed version forward (CAP-811). `PeerGitFetchEffect.alongside_refs` (`PeerGitRefsAlongside`)
+  and `PeerGitFetchResponse.alongside_refs` (`PeerGitRefsFetched`) carry a head-only mount's settled-letter outcome
+  refs beside main.
+
+## 0.13.0
+
+- `NomosApprovedModel` requires `unitSet`: the law a release approves is its unit set identity (the generated
+  `frameworkCalls.lawUnitSet`); `lawSha256` names the package closure. `AdoptApplicationModelRequest` carries
+  `unit_set`. `ApplicationBirthContract` is retired: a Home is born under the law its platform serves (CAP-773).
+- Live link frames: `LiveLinkClosure` and `PeerSocketClosure` record how a live connection closed (who ended it,
+  code, reason, duration and what it carried) (CAP-683, CAP-684).
+- Rows watches can receive only the rows that changed: `ApplicationResultDelta` and `FullResultReason` (CAP-731).
+  `OfferStateChange` names the aggregate types an offer changed, so a local offer re-reads only the watches it
+  can change (CAP-760).
+- `CustodianWarming` reports a custodian warming up as its own posture, not an error retry (CAP-769).
+- `ReadAccessPreparation` reports a device enrolled just in time for a granted read (CAP-740).
+- Carry the current generated kernel and Runtime v2 Protobuf contracts, including per-offer phase timings
+  (CAP-756) and residency rows (CAP-754).
+
 ## 0.12.0
 
 - Add the `LiveAdmission` live-link frame: the custodian's admission of a live batch, returned over the link (CAP-656).