@githolon/dsl 0.103.3 → 0.103.5

package/dart/pubspec.lock

@@ -191,7 +191,7 @@ packages:
       path: "../dart_types"
       relative: true
     source: path
-    version: "0.8.2"
+    version: "0.8.3"
   package_config:
     dependency: "direct main"
     description:

package/dart/pubspec.yaml

@@ -5,10 +5,9 @@
 name: nomos_client
 repository: https://github.com/Captain-App/nomos2
 description: >-
-  Nomos 2 Dart frontend types — the hand-written kernel wire types plus the
-  code-generated per-domain aggregate + directive-payload types. (De)serializes
-  the EXACT serde JSON the Rust kernel + projection produce/consume.
-version: 0.64.4
+  Nomos 2 Dart client — generated domain values, intent payloads and application
+  lifecycle types over the typed Nomos kernel protocol and USDA custody model.
+version: 0.64.6
 
 environment:
   sdk: ^3.5.0
@@ -17,7 +16,7 @@ dependencies:
   # The pure-data core (wire types, offer codec, NomosReads, schema validation, error
   # info). nomos_client depends on and re-exports it, so existing imports are unchanged.
   # For local monorepo dev, pubspec_overrides.yaml points this at ../dart_types.
-  nomos_types: ^0.8.2
+  nomos_types: ^0.8.3
   json_schema: ^5.2.2
   crypto: ^3.0.0
   package_config: ^2.1.0

package/dart/test/acquire_session_test.dart

@@ -100,7 +100,7 @@ void main() {
   });
 
   test(
-      'a plane-resident (parked) workspace opens LOCALLY — no cloud, credentials NOT invoked',
+      'a plane-resident workspace binds retained cloud credentials so background sync owns it',
       () async {
     final runner = FakeRunner(resident: ['estate']);
     final bridge = NomosBridge(runner);
@@ -112,12 +112,12 @@ void main() {
       asked = true;
       return const NomosSessionCredentials(cloud: 'https://never.invalid');
     });
-    expect(asked, isFalse,
-        reason: 'a resident workspace never asks for credentials');
+    expect(asked, isTrue,
+        reason:
+            'a generated resident child must acquire its continuous cloud posture');
     expect(s.workspace, 'estate');
     expect(runner.connectCount, 1);
-    expect(runner.connectArgs(0).containsKey('cloud'), isFalse,
-        reason: 'a resident open is local-only — no cloud in the connect');
+    expect(runner.connectArgs(0)['cloud'], 'https://never.invalid');
     await bridge.dispose();
   });
 
@@ -199,6 +199,63 @@ void main() {
     await bridge.dispose();
   });
 
+  test(
+      'generated child inherits typed model decisions and stages opaque USDZ privately',
+      () async {
+    final runner = FakeRunner(resident: ['child']);
+    final bridge = NomosBridge(runner);
+    await bridge.ready;
+    await bridge.connect(
+      workspace: 'home',
+      session: 'home',
+      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
+    );
+    var handled = false;
+    final home = bridge.session('home');
+    home.nomosInternalRetainModelChangeHandler((change) async {
+      handled = change.expectedDomainHash == 'candidate';
+    });
+    final child = await home.acquireSession('child');
+    await home.nomosInternalEnsureGeneratedModelInChild(
+      childWorkspace: 'child',
+      domain: 'catalogue',
+      candidateHash: 'candidate',
+      lawUsdz: const [1, 2, 3],
+    );
+    await child.nomosInternalHandleModelChange(
+      const DomainClientModelAdoptionRequired(
+        expectedDomainKey: 'catalogue',
+        expectedDomainHash: 'candidate',
+        status: 'needs-decision',
+        summary: 'review',
+        review: DomainModelReview(
+          checkedActions: 1,
+          candidateActions: 1,
+          sameOutcome: true,
+          differences: [],
+        ),
+      ),
+    );
+    expect(handled, isTrue);
+    final stage = runner.sent.singleWhere(
+      (message) => message['op'] == 'stageGeneratedModelFromParent',
+    );
+    expect((stage['args'] as Map)['sourceSession'], 'home');
+    expect((stage['args'] as Map)['session'], 'child');
+    expect((stage['args'] as Map)['lawUsdz'], 'AQID');
+    await home.nomosInternalStageGeneratedModel(
+      domain: 'catalogue',
+      candidateHash: 'candidate',
+      lawUsdz: const [4, 5, 6],
+    );
+    final rootStage = runner.sent.singleWhere(
+      (message) => message['op'] == 'stageGeneratedModel',
+    );
+    expect((rootStage['args'] as Map)['session'], 'home');
+    expect((rootStage['args'] as Map)['lawUsdz'], 'BAUG');
+    await bridge.dispose();
+  });
+
   test(
       'a generated application session privately refreshes cloud access for an absent referenced workspace',
       () async {

package/dart/test/cloud_bound_topology_test.dart

@@ -17,7 +17,6 @@
 import 'dart:convert';
 import 'dart:io';
 
-import 'package:crypto/crypto.dart' show sha256;
 import 'package:nomos_client/src/nms_conformance_runtime.dart';
 import 'package:test/test.dart';
 
@@ -29,8 +28,10 @@ String get _deploy =>
 const _subject = 'user:topology-test';
 
 String? _missingPrereq() {
-  if (!File(_repoEntry).existsSync()) return 'in-repo runner not found at $_repoEntry';
-  if (!File(_devServer).existsSync()) return 'in-repo dev server not found at $_devServer';
+  if (!File(_repoEntry).existsSync())
+    return 'in-repo runner not found at $_repoEntry';
+  if (!File(_devServer).existsSync())
+    return 'in-repo dev server not found at $_devServer';
   if (!File(_deploy).existsSync()) {
     return 'compile the fixture: cd bench/scale/fixtures/cloud-topology && node ../../../../dsl/compile_package.mjs — missing $_deploy';
   }
@@ -38,7 +39,8 @@ String? _missingPrereq() {
 }
 
 void main() {
-  test('the co2 topology: remote home ceremony → local estate birth offline → converge → remote custody',
+  test(
+      'the co2 topology: remote home ceremony → local estate birth offline → converge → remote custody',
       () async {
     final skip = _missingPrereq();
     if (skip != null) {
@@ -48,7 +50,12 @@ void main() {
     final diag = Platform.environment['NOMOS_HARNESS_DIAG'] == '1'
         ? (String l) => stderr.writeln(l)
         : null;
-    final cloud = await NomosTestCloud.start(serverEntry: _devServer, platform: 'topology-platform', lawUsdzPath: _deploy, onDiagnostic: diag);
+    final cloud = await NomosTestCloud.start(
+        serverEntry: _devServer,
+        platform: 'topology-platform',
+        lawUsdzPath: _deploy,
+        applicationMaxChildWorkspacesPerUser: 8,
+        onDiagnostic: diag);
     NomosTestHarness? harness;
     try {
       // 1+2 — the remote ceremony + the local mount, in one constructor (the app's boot path).
@@ -61,60 +68,69 @@ void main() {
         onDiagnostic: diag,
       );
       final home = harness.homeSession;
-      expect(home.workspace, startsWith('home-'),
-          reason: 'the remote ceremony born the deterministic home slot');
+      expect(home.workspace, isNotEmpty,
+          reason:
+              'the generated ceremony resolved the receiving group without exposing its naming scheme');
       final remoteHome = await cloud.remoteHead(home.workspace);
       expect(remoteHome.initialized, isTrue,
-          reason: 'the home was born REMOTELY (custody exists before the app ever mounted it)');
+          reason:
+              'the home was born REMOTELY (custody exists before the app ever mounted it)');
 
       // 3 — PARTITION.
       cloud.setOnline(false);
 
-      // 4 — the home births the estate LOCALLY (the app lane never needs the network).
-      // ownerKeyHash: the owner's device (enrolled in the home's genesis) — the estate enrols the SAME
-      // key at birth so it accepts the owner's signed writes from intent 0 (era-0 signer-ready births).
-      final ownerKeyHash = sha256
-          .convert(base64Decode(harness.devicePublicKey(home.workspace)!))
-          .toString();
+      // 4 — the home births the estate LOCALLY (the app lane never needs the network). The business
+      // payload contains business facts only; law selection, signer seating and child addressing are
+      // private consequences of the compiled birth declaration.
       final outcome = await harness.bridge.session(home.workspace).offerCreates(
-        domain: 'home',
-        directiveId: 'birthEstateWorkspace',
-        payload: {
-          'owner': _subject,
-          'frameworkHash': harness.frameworkHash,
-          'lawHash': harness.lawHashes(home.workspace).first,
-          'bornAt': '2026-07-14T00:00:00Z',
-          'ownerKeyHash': ownerKeyHash,
-        },
-        actor: _subject,
-      );
-      expect(outcome.born, isNotEmpty, reason: 'the local .births() offer spawned the estate');
+            domain: 'home',
+            directiveId: 'birthEstateWorkspace',
+            payload: {
+              'owner': _subject,
+              'establishedAt': '2026-07-14T00:00:00Z',
+              'principal': _subject,
+              'bornAt': '2026-07-14T00:00:00Z',
+            },
+            actor: _subject,
+          );
+      expect(outcome.born, isNotEmpty,
+          reason: 'the local .births() offer spawned the estate');
       final estateWs = outcome.born.single;
       expect(estateWs, startsWith('estate-'));
 
       // 5 — the estate opens as a sibling session and accepts a LOCAL WRITE while offline.
-      final estate = await harness.bridge.acquireSession(estateWs, authorSecret: harness.deviceSecret(home.workspace));
-      await estate.offerCreates(
+      final estate = await home.acquireSession(estateWs,
+          authorSecret: harness.deviceSecret(home.workspace));
+      final estateWrite = await estate.offerCreates(
         domain: 'estate',
         directiveId: 'writeEstateNote',
-        payload: {'author': _subject, 'body': 'written offline', 'writtenAt': '2026-07-14T00:00:01Z'},
+        payload: {
+          'author': _subject,
+          'body': 'written offline',
+          'writtenAt': '2026-07-14T00:00:01Z'
+        },
         actor: _subject,
       );
 
       // 6 — the UI-facing query returns the write IMMEDIATELY (local projection; nothing awaited sync).
-      final localRows = await estate.query('notesByAuthor', {'author': _subject});
+      final localRows =
+          await estate.query('notesByAuthor', {'author': _subject});
       expect(localRows, hasLength(1));
       expect((localRows.single['data'] as Map)['body'], 'written offline');
 
       // …and the estate has NO remote custody yet — the partition is real.
       final remoteEstateOffline = await cloud.remoteHead(estateWs);
       expect(remoteEstateOffline.initialized, isFalse,
-          reason: 'while partitioned, the locally-born estate must have NO remote custody');
+          reason:
+              'while partitioned, the locally-born estate must have NO remote custody');
 
-      // 7+8 — HEAL, then converge parent-first (home's chain lands; its birth offer-effect creates the
-      // estate's remote custody; the estate then converges against it).
+      // 7+8 — HEAL. The generated runtime owns reconnect and parent/child custody ordering. Await the two
+      // exact operation receipts; the test never calls sync(), names an endpoint or infers convergence.
       cloud.setOnline(true);
-      await harness.converge(timeout: const Duration(seconds: 180));
+      await Future.wait([
+        outcome.receipt.converged,
+        estateWrite.receipt.converged,
+      ]).timeout(const Duration(seconds: 180));
 
       // 9 — a FRESH observer: the dev cloud's own remote projection serves the estate write.
       final http = HttpClient();
@@ -125,8 +141,10 @@ void main() {
         final body = jsonDecode(await resp.transform(utf8.decoder).join());
         final rows = ((body as Map)['rows'] as List?) ?? const [];
         expect(rows, hasLength(1),
-            reason: 'the remote projection (a fresh observer) serves the offline-written note after converge');
-        expect(((rows.single as Map)['data'] as Map)['body'], 'written offline');
+            reason:
+                'the remote projection (a fresh observer) serves the offline-written note after converge');
+        expect(
+            ((rows.single as Map)['data'] as Map)['body'], 'written offline');
       } finally {
         http.close(force: true);
       }
@@ -137,10 +155,13 @@ void main() {
       expect(remoteHome2.initialized, isTrue);
       expect(remoteHome2.commits, greaterThan(0));
       expect(remoteEstate2.initialized, isTrue,
-          reason: 'converge established the estate\'s remote custody (parent birth folded remotely)');
+          reason:
+              'converge established the estate\'s remote custody (parent birth folded remotely)');
       expect(remoteEstate2.commits, greaterThan(0));
     } finally {
-      try { await harness?.dispose(); } catch (_) {}
+      try {
+        await harness?.dispose();
+      } catch (_) {}
       await cloud.stop();
     }
   }, timeout: const Timeout(Duration(minutes: 6)));

package/dart/test/session_bound_test.dart

@@ -13,11 +13,8 @@
 @TestOn('vm')
 library;
 
-import 'dart:convert';
 import 'dart:io';
 
-import 'package:crypto/crypto.dart' show sha256;
-
 // ignore: deprecated_member_use
 import 'package:nomos_client/src/nms_conformance_runtime.dart';
 import 'package:test/test.dart';
@@ -54,11 +51,6 @@ String? _missingPrereq() {
   return null;
 }
 
-/// The owner-device keyHash (the harness device the install lane minted) — the estate enrols it at birth
-/// so the born child accepts the owner's signed writes (era-0 signer-ready births).
-String _ownerKeyHash(NomosTestHarness h) =>
-    sha256.convert(base64Decode(h.devicePublicKey(h.workspace)!)).toString();
-
 Future<NomosTestHarness> _harness() => NomosTestHarness.ephemeral(
       lawUsdzPaths: [_deployJson],
       nodeEntry: _repoEntry,
@@ -70,14 +62,12 @@ Future<NomosOfferOutcome> _birthEstate(
   NomosSession session,
   NomosTestHarness harness, {
   String owner = _owner,
-  bool enrollOwnerKey = true,
 }) {
   final facts = BirthEstateWorkspacePayload(
     owner: owner,
     frameworkHash: harness.frameworkHash!,
     lawHash: harness.lawHashes(harness.workspace).first,
     bornAt: DateTime.now().toUtc().toIso8601String(),
-    ownerKeyHash: enrollOwnerKey ? _ownerKeyHash(harness) : null,
   );
   return session.offerOutcome(
     domain: 'home',
@@ -88,6 +78,31 @@ Future<NomosOfferOutcome> _birthEstate(
 }
 
 void main() {
+  test('an installed domain missing a required member is a newer-client shape',
+      () {
+    expect(
+      nmsInternalClientExpectsNewerInterface(
+        domain: 'home',
+        activeDomainKeys: const ['home', 'nomos'],
+        missing: const ['CatalogueAccessIndexEntry.catalogueWorkspace'],
+        incompatible: const [],
+      ),
+      isTrue,
+      reason:
+          'the generated candidate must enter exact-history adoption instead of deployment diagnostics',
+    );
+    expect(
+      nmsInternalClientExpectsNewerInterface(
+        domain: 'home',
+        activeDomainKeys: const ['catalogue', 'nomos'],
+        missing: const ['home'],
+        incompatible: const [],
+      ),
+      isFalse,
+      reason: 'a genuinely absent domain keeps the not-deployed diagnosis',
+    );
+  });
+
   test(
       'generated applications: mount → bind (preflight) → fixture birth → follow(ref) → '
       'second application → typed record operation', () async {