@githolon/dsl 0.100.6 → 0.101.0

package/dart/pubspec.lock

@@ -191,7 +191,7 @@ packages:
       path: "../dart_types"
       relative: true
     source: path
-    version: "0.6.0"
+    version: "0.7.0"
   package_config:
     dependency: transitive
     description:

package/dart/pubspec.yaml

@@ -11,7 +11,7 @@ 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.62.2
+version: 0.63.0
 
 environment:
   sdk: ^3.5.0
@@ -20,7 +20,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.6.0
+  nomos_types: ^0.7.0
   json_schema: ^5.2.2
   crypto: ^3.0.0
 

package/dart/test/bundle_version_pairing_test.dart

@@ -1,7 +1,6 @@
-// THE VERSION-PAIRING TRIPWIRE (the pubspec-pins pattern): kExpectedRunnerBundleVersion must equal
-// the @githolon/client version this repo is about to release (cloud/web-client/package.json) — a
-// client release without the Dart floor bump (or vice versa) fails the suite, so the stale-bundle
-// check can neither lag (missing real staleness) nor lead (refusing the current bundle).
+// THE VERSION-FLOOR TRIPWIRE: the @githolon/client built by this checkout must satisfy the minimum
+// runner version declared by nomos_client. Changesets may advance the npm package metadata without
+// changing its protocol, so a newer runner is valid; an older runner than the Dart floor is not.
 import 'dart:convert';
 import 'dart:io';
 
@@ -16,25 +15,15 @@ void main() {
       return;
     }
     final v = (jsonDecode(f.readAsStringSync()) as Map)['version'] as String;
-    if (kExpectedRunnerBundleVersion == v) return; // released state: exact pair
-    // PENDING-RELEASE state: the floor may lead package.json by exactly the bump a queued
-    // changeset will apply (the changesets flow bumps package.json only when the version PR
-    // merges). Anything else — lagging, or leading with no changeset queued — is drift.
-    final changesets = Directory('${Directory.current.path}/../../.changeset')
-        .listSync()
-        .whereType<File>()
-        .where((c) => c.path.endsWith('.md') && !c.path.endsWith('README.md'))
-        .where((c) => c.readAsStringSync().contains('@githolon/client'));
-    expect(changesets, isNotEmpty,
-        reason: 'kExpectedRunnerBundleVersion ($kExpectedRunnerBundleVersion) != @githolon/client '
-            '($v) and NO client changeset is queued — bump the floor WITH the client release '
-            '(the stale-bundle floor must move with the bundle it ships beside)');
     List<int> parse(String x) =>
         x.split('.').map((p) => int.tryParse(p) ?? 0).toList();
-    final a = parse(kExpectedRunnerBundleVersion), b = parse(v);
-    final leads = a[0] > b[0] ||
-        (a[0] == b[0] && (a[1] > b[1] || (a[1] == b[1] && a[2] > b[2])));
-    expect(leads, isTrue,
-        reason: 'the floor must LEAD (never lag) package.json while a release is queued');
+    final floor = parse(kExpectedRunnerBundleVersion), runner = parse(v);
+    final runnerMeetsFloor = runner[0] > floor[0] ||
+        (runner[0] == floor[0] &&
+            (runner[1] > floor[1] ||
+                (runner[1] == floor[1] && runner[2] >= floor[2])));
+    expect(runnerMeetsFloor, isTrue,
+        reason: '@githolon/client $v is older than nomos_client runner floor '
+            '$kExpectedRunnerBundleVersion');
   });
 }

package/dart/test/co2_product_gauntlet_test.dart

@@ -0,0 +1,228 @@
+// Product acceptance: application → home → Estate, then Site → Asset, through the generated Dart client.
+// The harness owns the test cloud and framework ceremony; the application section supplies business facts.
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:nomos_client/nomos_headless.dart';
+import 'package:test/test.dart';
+
+import '../../../examples/co2-birth/build/dart/src/generated/co2.client.dart';
+
+String get _root => '${Directory.current.path}/../..';
+String get _runner =>
+    Platform.environment['NOMOS_NODE_ENTRY'] ??
+    '$_root/cloud/web-client/runner/node-entry.ts';
+String get _server => '$_root/cloud/dev-server/server.ts';
+String get _deploy =>
+    Platform.environment['NOMOS_CO2_DEPLOY'] ??
+    '$_root/examples/co2-birth/build/co2.deploy.json';
+const _subject = 'user:co2-product-owner';
+
+Future<T> _eventually<T>(
+  String description,
+  Future<T?> Function() probe, {
+  Duration timeout = const Duration(seconds: 90),
+}) async {
+  final deadline = DateTime.now().add(timeout);
+  Object? lastError;
+  while (DateTime.now().isBefore(deadline)) {
+    try {
+      final value = await probe();
+      if (value != null) return value;
+    } catch (error) {
+      lastError = error;
+    }
+    await Future<void>.delayed(const Duration(milliseconds: 250));
+  }
+  throw TestFailure(
+      '$description did not become true within ${timeout.inSeconds}s${lastError == null ? '' : ': $lastError'}');
+}
+
+void main() {
+  test(
+      'CO2 product journey: application → home → Estate → Site → Asset, offline then remotely durable',
+      () async {
+    final required = Platform.environment['NOMOS_GAUNTLET_REQUIRED'] == '1';
+    final missing = [_runner, _server, _deploy]
+        .where((path) => !File(path).existsSync())
+        .toList();
+    if (missing.isNotEmpty) {
+      if (required)
+        fail(
+            'CO2 product gauntlet prerequisites are missing: ${missing.join(', ')}');
+      markTestSkipped(
+          'CO2 product gauntlet prerequisites are missing: ${missing.join(', ')}');
+      return;
+    }
+
+    final diagnostic = Platform.environment['NOMOS_HARNESS_DIAG'] == '1'
+        ? (String line) => stderr.writeln(line)
+        : null;
+    final cloud = await NomosTestCloud.start(
+      serverEntry: _server,
+      platform: 'co2-product-platform',
+      deployJsonPath: _deploy,
+      onDiagnostic: diagnostic,
+    );
+    NomosTestHarness? harness;
+    try {
+      // Release coherence is part of sync correctness, not an optional diagnostic. If the cloud cannot
+      // identify the kernel that will receive these ledgers, a successful local write is not an adequate
+      // product proof: the client would be synchronising into an unknown fold implementation.
+      final capabilitiesHttp = HttpClient();
+      try {
+        final request = await capabilitiesHttp
+            .getUrl(Uri.parse('${cloud.origin}/v1/runtime/capabilities'));
+        final response = await request.close();
+        final text = await response.transform(utf8.decoder).join();
+        expect(response.statusCode, HttpStatus.ok,
+            reason:
+                'the cloud must advertise the kernel that will receive offline ledgers: $text');
+        final capabilities = (jsonDecode(text) as Map).cast<String, Object?>();
+        final production =
+            (capabilities['prod'] as Map?)?.cast<String, Object?>() ?? const {};
+        final features = ((production['features'] as List?) ?? const [])
+            .map((feature) => feature.toString())
+            .toSet();
+        expect(
+            features,
+            containsAll(<String>[
+              'conflictSnapshots',
+              'ownedAudience',
+            ]),
+            reason:
+                'the receiving kernel must support the law we are about to sync');
+      } finally {
+        capabilitiesHttp.close(force: true);
+      }
+
+      harness = await NomosTestHarness.cloudBound(
+        cloud: cloud,
+        deployJsonPaths: [_deploy],
+        platformWorkspace: 'co2-product-platform',
+        subject: _subject,
+        nodeEntry: _runner,
+        onDiagnostic: diagnostic,
+        phaseTimeout: const Duration(seconds: 180),
+      );
+      final home = harness.homeSession;
+      expect((await cloud.remoteHead(home.workspace)).initialized, isTrue,
+          reason:
+              'the application born the identity home before business code ran');
+      // The shipped Flutter scope starts this automatically. The headless acceptance test calls the same
+      // client-owned lifecycle explicitly because it has no widget scope; no later sync/converge call is
+      // permitted. The 60s fallback remains deliberately large: recovery must come from retry/reconnect,
+      // not a test-only tight poll.
+      await home.autoSync(fallbackMs: 60000);
+
+      cloud.setOnline(false);
+
+      // This is the whole tenant journey. Every argument is a business fact; Nomos owns the offline birth,
+      // child acquisition, authorship, persistence, routing, retry and eventual parent-first custody.
+      final homeClient = await Co2Client.bind(home, actor: _subject);
+      final estateRef = await homeClient.birth(NomosBirthEstatePayload(
+        reference: 'E-001',
+        name: 'Foundry',
+        country: 'GB',
+        baselineTonnesCo2e: 4200,
+      ));
+      final estate = await harness.bridge.follow(
+        estateRef,
+        authorSecret: harness.deviceSecret(home.workspace),
+      );
+      await estate.autoSync(fallbackMs: 60000);
+      final estateClient = await Co2Client.bind(estate, actor: _subject);
+      final site = await estateClient.addSite(
+        AddSitePayload(estateId: estateRef.id, name: 'Trafford Depot'),
+      );
+      final siteId = site.created.single.id;
+      await estateClient.addAsset(AddAssetPayload(
+        siteId: siteId,
+        name: 'Main electricity meter',
+        operationalStatus: 'commissioned',
+      ));
+      final localAssets = await estateClient.assetsBySite(siteId: siteId);
+      expect(localAssets.single.name, 'Main electricity meter');
+      expect(localAssets.single.operationalStatus?.valueOrNull, 'commissioned');
+
+      expect((await cloud.remoteHead(estateRef.workspace)).initialized, isFalse,
+          reason:
+              'the Estate remained fully usable without remote custody during the partition');
+
+      cloud.setOnline(true);
+      // No tenant sync(), no harness.converge(), no topology ordering. The two stateful client sessions must
+      // retain their local branches, retry after reconnect, establish the parent birth first as required by
+      // the law, and finish child custody themselves.
+      await _eventually('client-owned parent and child convergence', () async {
+        final homeRemote = await cloud.remoteHead(home.workspace);
+        final estateRemote = await cloud.remoteHead(estateRef.workspace);
+        final homeMetrics = await home.metrics();
+        final estateMetrics = await estate.metrics();
+        final homeAhead = (homeMetrics['ahead'] as num?)?.toInt() ?? -1;
+        final estateAhead = (estateMetrics['ahead'] as num?)?.toInt() ?? -1;
+        if (homeRemote.initialized &&
+            estateRemote.initialized &&
+            homeAhead == 0 &&
+            estateAhead == 0) {
+          return true;
+        }
+        return null;
+      }, timeout: const Duration(seconds: 180));
+
+      final http = HttpClient();
+      try {
+        final request = await http.getUrl(Uri.parse(
+          '${cloud.origin}/v2/workspaces/${estateRef.workspace}/assetsBySite?siteId=${Uri.encodeQueryComponent(siteId)}',
+        ));
+        final response = await request.close();
+        final body =
+            (jsonDecode(await response.transform(utf8.decoder).join()) as Map)
+                .cast<String, Object?>();
+        final rows = (body['rows'] as List?) ?? const [];
+        expect(rows, hasLength(1));
+        expect(((rows.single as Map)['data'] as Map)['name'],
+            'Main electricity meter');
+      } finally {
+        http.close(force: true);
+      }
+
+      final remoteEstate = await cloud.remoteHead(estateRef.workspace);
+      expect(remoteEstate.initialized, isTrue);
+      expect(remoteEstate.commits, greaterThan(0));
+
+      // The serving cloud is not the proof of replayability. Start a fresh runner with no resident custody,
+      // clone the Estate from remote custody, and re-fire the complete authority/law chain locally.
+      final coldTransport = await NodeRunnerTransport.start(
+        entry: _runner,
+        environment: cloud.testKRootPublic == null
+            ? null
+            : {
+                ...Platform.environment,
+                'NOMOS_TEST_K_ROOT_PUBLIC': cloud.testKRootPublic!,
+              },
+      );
+      final cold = NomosBridge(coldTransport);
+      try {
+        await cold.ready;
+        await cold.connect(
+          cloud: cloud.origin,
+          workspace: estateRef.workspace,
+          clientId: 'co2-product-cold-peer',
+        );
+        final coldSession = cold.session(estateRef.workspace);
+        final coldClient = await Co2Client.bind(coldSession, actor: _subject);
+        expect((await coldClient.assetsBySite(siteId: siteId)).single.name,
+            'Main electricity meter');
+        expect((await coldSession.verifyChain())['valid'], isTrue);
+      } finally {
+        await cold.dispose();
+        await coldTransport.dispose();
+      }
+    } finally {
+      try {
+        await harness?.dispose();
+      } catch (_) {}
+      await cloud.stop();
+    }
+  }, timeout: const Timeout(Duration(minutes: 7)));
+}

package/dart/test/errors_test.dart

@@ -4,11 +4,45 @@
 import 'package:nomos_client/nomos_client.dart';
 import 'package:test/test.dart';
 
-NomosErrorInfo info(String code, {Map<String, Object?> attrs = const {}, String? workspace, String? operation}) =>
-    NomosErrorInfo(code: code, message: 'refused', workspace: workspace, operation: operation, attributes: attrs);
+NomosErrorInfo info(String code,
+        {Map<String, Object?> attrs = const {},
+        String? workspace,
+        String? operation}) =>
+    NomosErrorInfo(
+        code: code,
+        message: 'refused',
+        workspace: workspace,
+        operation: operation,
+        attributes: attrs);
 
 void main() {
-  test('law.* mints LawMismatchError with both sides + compat verdict + the exact message', () {
+  test(
+      'owned recovery mints one typed resumable state with the private protocol hidden',
+      () {
+    final e = nomosErrorFromInfo(info(
+      'nomos.owned.recovery_pending',
+      workspace: 'home-ada',
+      attrs: {
+        'nomos.owned.stage': 'awaitingRecoveryPrincipal',
+        'nomos.owned.orderId': 'NomosOwnedRecoveryOrder_1',
+        'nomos.owned.recoveryPrincipal': 'user:bob',
+        'nomos.owned.recommendedAction':
+            NomosRecommendedAction.openRecoveryPrincipalDevice,
+      },
+    ));
+    expect(e, isA<OwnedRecoveryPending>());
+    final recovery = e as OwnedRecoveryPending;
+    expect(recovery.workspace, 'home-ada');
+    expect(recovery.stage, 'awaitingRecoveryPrincipal');
+    expect(recovery.orderId, 'NomosOwnedRecoveryOrder_1');
+    expect(recovery.recoveryPrincipal, 'user:bob');
+    expect(recovery.recommendedAction,
+        NomosRecommendedAction.openRecoveryPrincipalDevice);
+  });
+
+  test(
+      'law.* mints LawMismatchError with both sides + compat verdict + the exact message',
+      () {
     final e = nomosErrorFromInfo(info(
       'nomos.law.mismatch',
       workspace: 'ws-1',
@@ -44,11 +78,15 @@ void main() {
       'nomos.law.workspaceRuns': 'bbbb',
       'nomos.law.structurallyCompatible': true,
     })) as LawMismatchError;
-    expect(m.mismatchMessage, startsWith('client generated for law aaaa, workspace runs law bbbb; structurally compatible — proceeding —'));
+    expect(
+        m.mismatchMessage,
+        startsWith(
+            'client generated for law aaaa, workspace runs law bbbb; structurally compatible — proceeding —'));
   });
 
   test('auth.* mints AuthError with reauth as the remedy', () {
-    final e = nomosErrorFromInfo(info('nomos.auth.issuer_mismatch', workspace: 'ws-1', attrs: {'nomos.auth.issuer': 'https://evil'}));
+    final e = nomosErrorFromInfo(info('nomos.auth.issuer_mismatch',
+        workspace: 'ws-1', attrs: {'nomos.auth.issuer': 'https://evil'}));
     expect(e, isA<AuthError>());
     final a = e as AuthError;
     expect(a.code, 'nomos.auth.issuer_mismatch');
@@ -68,7 +106,9 @@ void main() {
     expect(l.recommendedAction, NomosRecommendedAction.retry);
   });
 
-  test('authz signer_enrollment_missing mints ParentSignerEnrollmentMissing with the ONE remedy', () {
+  test(
+      'authz signer_enrollment_missing mints ParentSignerEnrollmentMissing with the ONE remedy',
+      () {
     final e = nomosErrorFromInfo(info(
       'nomos.authz.signer_enrollment_missing',
       workspace: 'co2-platform',
@@ -90,18 +130,26 @@ void main() {
     expect(p.object, 'identity:u-1');
     expect(p.relation, 'signer');
     expect(p.directiveId, 'birthEstateWorkspace');
-    expect(p.recommendedAction, NomosRecommendedAction.ensureParentSignerEnrollment);
+    expect(p.recommendedAction,
+        NomosRecommendedAction.ensureParentSignerEnrollment);
   });
 
-  test('authz cause=missing-signer-enrollment routes to ParentSignerEnrollmentMissing even under the generic code', () {
+  test(
+      'authz cause=missing-signer-enrollment routes to ParentSignerEnrollmentMissing even under the generic code',
+      () {
     final e = nomosErrorFromInfo(info(
       'nomos.authz.refused',
-      attrs: {'nomos.authz.cause': 'missing-signer-enrollment', 'nomos.authz.actor': 'user:u-9'},
+      attrs: {
+        'nomos.authz.cause': 'missing-signer-enrollment',
+        'nomos.authz.actor': 'user:u-9'
+      },
     ));
     expect(e, isA<ParentSignerEnrollmentMissing>());
   });
 
-  test('authz missing_role stays AuthzRefusedError — role-absent is DISTINGUISHED from signer-absent', () {
+  test(
+      'authz missing_role stays AuthzRefusedError — role-absent is DISTINGUISHED from signer-absent',
+      () {
     final e = nomosErrorFromInfo(info(
       'nomos.authz.missing_role',
       workspace: 'ws-1',
@@ -120,8 +168,11 @@ void main() {
     expect(a.object, 'workspace:self');
   });
 
-  test('custody.* still mints CustodyError (unchanged), unknown codes stay generic', () {
-    expect(nomosErrorFromInfo(info('nomos.custody.missing_object')), isA<CustodyError>());
+  test(
+      'custody.* still mints CustodyError (unchanged), unknown codes stay generic',
+      () {
+    expect(nomosErrorFromInfo(info('nomos.custody.missing_object')),
+        isA<CustodyError>());
     final g = nomosErrorFromInfo(info('nomos.bridge.error'));
     expect(g, isA<NomosBridgeError>());
     expect(g, isNot(isA<LawMismatchError>()));

package/dart/test/first_app_gauntlet_test.dart

@@ -115,6 +115,9 @@ void main() {
       // keyed 3b legs all log enter AND exit lines.
       expect(diagnostics.any((l) => l.contains('offline law install')), isTrue,
           reason: 'phase 1 install diagnostics must appear');
+      expect(diagnostics.any((l) => l.startsWith('[offline-install]')), isTrue,
+          reason:
+              'an in-repo runner must install through its adjacent in-repo helper, never silently fall back to the published CLI');
       expect(
           diagnostics
               .any((l) => l.contains('runner ready') && l.contains('done')),
@@ -134,11 +137,11 @@ void main() {
     });
 
     try {
-      // ── LEG 2: the blessed session-bound shape — mount → bind (preflight) → one business birth
-      //    → follow(ref) → second client → typed read. Zero routing/security strings. ──
+      // ── LEG 2: the blessed session-bound shape — one business birth, then Estate → Site → Asset
+      //    through the generated Dart client. Zero routing/security strings. ──
       final home = harness.session('home');
       final bornEstate = await _leg(
-          'leg 2: blessed shape (bind → business birth → follow → 2nd client → typed read)',
+          'leg 2: generated business shape (Estate → Site → Asset)',
           () async {
         final homeClient = await Co2Client.bind(home, actor: _owner);
         expect(homeClient.session!.workspace, home.workspace,
@@ -166,6 +169,29 @@ void main() {
             reason: 'the born business root reads back typed');
         expect(rows.single.reference, 'E-001');
         expect(rows.single.name, 'Foundry');
+
+        final siteOutcome = await estateClient.addSite(
+          AddSitePayload(estateId: ref.id, name: 'Trafford Depot'),
+        );
+        final siteRef = siteOutcome.created.single.ref;
+        expect(siteRef.type, 'co2.Site');
+        final sites = await estateClient.sitesByEstate(estateId: ref.id);
+        expect(sites, hasLength(1));
+        expect(sites.single.name, 'Trafford Depot');
+
+        final assetOutcome = await estateClient.addAsset(
+          AddAssetPayload(
+            siteId: siteRef.id,
+            name: 'Main electricity meter',
+            operationalStatus: 'commissioned',
+          ),
+        );
+        final assetRef = assetOutcome.created.single.ref;
+        expect(assetRef.type, 'co2.Asset');
+        final assets = await estateClient.assetsBySite(siteId: siteRef.id);
+        expect(assets, hasLength(1));
+        expect(assets.single.name, 'Main electricity meter');
+        expect(assets.single.operationalStatus?.valueOrNull, 'commissioned');
         return (session: estateSession, ref: ref);
       });
       final estate = bornEstate.session;