@githolon/dsl 0.108.7 → 0.110.1

package/dart/test/cluster_scale_test.dart

@@ -1,122 +0,0 @@
-// SCALE SANITY — DART LEG (task #42). "A device holds dozens of live workspaces" is a TESTED truth here,
-// not a slogan: one bridge / one runner / ONE shared engine plane mounts ~20 local-only workspaces, each with
-// the SAME tenant law installed offline (one compiled fixture's deploy.json, reused N times — same law, N
-// distinct workspaces), then writes + reads each in isolation and asserts `listWorkspaces` surfaces all 20.
-//
-// This is the colocation architecture the shared engine plane (openRealm) exists for: N workspaces on ONE
-// wasm engine, not N engines. The suite is deliberately DOZENS (CI-friendly), not hundreds — enough to pin
-// the "many live workspaces per device" claim while completing in sane wall-clock time (asserted below).
-@TestOn('vm')
-library;
-
-import 'dart:io';
-
-import 'package:nomos_client/src/nms_conformance_runtime.dart';
-import 'package:nomos_types/nomos_kernel_protocol.dart' as protocol;
-import 'package:test/test.dart';
-
-String get _root => '${Directory.current.path}/../..';
-String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.ts';
-String get _guestbookDeploy => '$_root/examples/guestbook/build/guestbook.law.usdz';
-String get _runtimeDir =>
-    Platform.environment['NOMOS_DART_RUNTIME'] ??
-    Platform.environment['NOMOS_OFFLINE_RUNTIME'] ??
-    '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
-
-/// How many colocated workspaces to open on the one plane. Dozens (CI-friendly), tunable via env for a
-/// heavier local soak (`NOMOS_SCALE_N=100 dart test test/cluster_scale_test.dart`).
-int get _n => int.tryParse(Platform.environment['NOMOS_SCALE_N'] ?? '') ?? 20;
-
-String? _missingPrereq() {
-  if (!File(_repoEntry).existsSync()) return 'in-repo runner not found at $_repoEntry';
-  if (!File(_guestbookDeploy).existsSync()) {
-    return 'compile the guestbook example: cd examples/guestbook && npx nomos-compile — missing $_guestbookDeploy';
-  }
-  if (!File('$_runtimeDir/holon-testmint.wasm').existsSync() ||
-      !File('$_runtimeDir/bootstrap.law.usdz').existsSync() ||
-      !File('$_runtimeDir/nomos.law.usdz').existsSync()) {
-    return 'warm ~/.holon/runtime first (run any `githolon` command once)';
-  }
-  return null;
-}
-
-void main() {
-  test('a device holds dozens of live workspaces on ONE engine plane — write + read each, all listed',
-      () async {
-    final skip = _missingPrereq();
-    if (skip != null) {
-      markTestSkipped(skip);
-      return;
-    }
-
-    final names = [for (var i = 0; i < _n; i++) 'ws-${i.toString().padLeft(2, '0')}'];
-    // Same law (one deploy.json), N distinct workspaces — the exact "one device, many workspaces" shape.
-    final workspaces = {for (final ws in names) ws: [_guestbookDeploy]};
-
-    final sw = Stopwatch()..start();
-    final harness = await NomosTestHarness.cluster(
-      workspaces: workspaces,
-      nodeEntry: _repoEntry,
-      runtimeDir: _runtimeDir,
-      // Installing + mounting N workspaces takes longer than the single-session default; give it headroom.
-      readyTimeout: const Duration(seconds: 90),
-    );
-    final openMs = sw.elapsedMilliseconds;
-    try {
-      expect(harness.sessions.toSet(), names.toSet(),
-          reason: 'all $_n workspaces connected as sessions on the one bridge');
-
-      // WRITE one row into each workspace, keyed by its own name — so a cross-workspace read must come back
-      // EMPTY (isolation) and the own-workspace read must return exactly the one row (no bleed on the plane).
-      sw.reset();
-      for (final ws in names) {
-        await harness.session(ws).offerDirective(
-          domain: 'guestbook',
-          directiveId: 'signGuestbook',
-          payload: {
-            'author': ws,
-            'message': 'hello from $ws',
-            'mood': 'delighted',
-            'signedAt': '2026-07-05T00:00:00Z',
-          },
-          actor: ws,
-        );
-      }
-      final writeMs = sw.elapsedMilliseconds;
-
-      // READ each back — the own author returns its single row; a foreign author returns nothing (isolation).
-      sw.reset();
-      for (final ws in names) {
-        final own = await harness.session(ws).query('entriesByAuthor', {'author': ws});
-        expect(own, hasLength(1), reason: '$ws holds exactly its own 1 row');
-        expect(own.first['data']?['message'], 'hello from $ws');
-
-        final foreign = names.firstWhere((o) => o != ws);
-        final cross = await harness.session(ws).query('entriesByAuthor', {'author': foreign});
-        expect(cross, isEmpty, reason: '$ws does NOT see $foreign\'s data — per-workspace isolation');
-      }
-      final readMs = sw.elapsedMilliseconds;
-
-      // listWorkspaces enumerates the whole local plane — every one of the N is present + mounted.
-      final listed = await harness.bridge.listWorkspaces();
-      expect(listed.map((workspace) => workspace.session).toSet(), names.toSet(),
-          reason: 'listWorkspaces surfaces all $_n live workspaces');
-      expect(listed.every((workspace) => workspace.residency == protocol.WorkspaceResidency.WORKSPACE_RESIDENCY_MOUNTED), isTrue,
-          reason: 'every listed workspace is mounted');
-
-      // Wall-clock sanity — dozens of live workspaces must open + drive in a CI-sane budget, not minutes.
-      // Generous ceilings (CI is slow); the point is "seconds per workspace is a bug", not a micro-benchmark.
-      // ignore: avoid_print
-      print('[scale] $_n workspaces: open+install ${openMs}ms, '
-          'write ${writeMs}ms (${(writeMs / _n).toStringAsFixed(1)}ms/ws), '
-          'read ${readMs}ms (${(readMs / _n).toStringAsFixed(1)}ms/ws)');
-      expect(writeMs, lessThan(_n * 5000),
-          reason: 'per-workspace write stays well under a 5s/ws ceiling (got ${(writeMs / _n).round()}ms/ws)');
-      expect(readMs, lessThan(_n * 5000),
-          reason: 'per-workspace read stays well under a 5s/ws ceiling (got ${(readMs / _n).round()}ms/ws)');
-    } finally {
-      await harness.dispose();
-    }
-    // The whole suite (open + install + write + read + teardown of N workspaces) completes in sane time.
-  }, timeout: const Timeout(Duration(minutes: 10)));
-}

package/dart/test/compat_test.dart

@@ -1,61 +0,0 @@
-// COMPAT SUPERPOWER (#72b) — the Dart mirror of `holon.compat`. NomosCompat.fromJson round-trips
-// the bridge's plain verdict snapshot; has() is the dark-launch feature flag over the per-member map.
-import 'package:nomos_client/src/nms_generated_runtime.dart';
-import 'package:test/test.dart';
-
-Map<String, Object?> verdict({
-  required String v,
-  required Map<String, Object?> members,
-  String phase = 'Active',
-  String? supersededBy,
-}) =>
-    {
-      'generatedFor': 'a' * 64,
-      'workspaceRuns': ['b' * 64],
-      'matches': false,
-      'offerKnown': true,
-      'structurallyCompatible': v != 'incompatible',
-      'verdict': v,
-      'members': members,
-      'install': {'phase': phase, if (supersededBy != null) 'supersededBy': supersededBy},
-    };
-
-void main() {
-  test('fromJson parses the three-state verdict + per-member map + install phase', () {
-    final c = NomosCompat.fromJson(verdict(
-      v: 'degraded',
-      members: {
-        'writeNote': {'ok': true},
-        'Note': {'ok': true},
-      },
-      phase: 'Superseded',
-      supersededBy: 'c' * 64,
-    ))!;
-    expect(c.verdict, 'degraded');
-    expect(c.offerKnown, isTrue);
-    expect(c.structurallyCompatible, isTrue);
-    expect(c.installPhase, 'Superseded');
-    expect(c.supersededBy, 'c' * 64);
-    expect(c.members.keys, containsAll(['writeNote', 'Note']));
-  });
-
-  test('has() is the feature flag — true for a compatible member, false otherwise', () {
-    final c = NomosCompat.fromJson(verdict(
-      v: 'incompatible',
-      members: {
-        'writeNote': {'ok': false, 'reason': "workspace requires field 'sig' the client does not always send"},
-        'Note': {'ok': true},
-      },
-    ))!;
-    // the served + compatible member lights up; the broken one + an unknown one stay dark
-    expect(c.has('Note'), isTrue);
-    expect(c.has('writeNote'), isFalse);
-    expect(c.has('somethingElse'), isFalse);
-    // the broken member still carries its reason (for the app to surface)
-    expect(c.members['writeNote']!.reason, contains('sig'));
-  });
-
-  test('fromJson(null) is null (compat-less / pre-#72e)', () {
-    expect(NomosCompat.fromJson(null), isNull);
-  });
-}

package/dart/test/dlq_session_surface_test.dart

@@ -1,222 +0,0 @@
-// THE DEAD-LETTER QUEUE FROM THE DART SESSION SURFACE (task #86 gap 7). The DLQ promise —
-// "refused-but-legitimate work is NEVER lost" — driven end-to-end through the Dart bridge:
-// real authored work (its full intent bytes, read back via the production `salvage` lane) is
-// parked as a dead letter on a workspace whose law cannot merge it (the exact shape a domain
-// rejection parks — same `deadLetter()` path the converge/recover lanes use), then:
-//   deadLetters() surfaces it with provenance → retry REFUSES while the law is absent (the
-//   entry stays, error refreshed) → the law fix ships (nomos/installDomain) → retry ADMITS and
-//   the work lands, readable → a second entry is explicitly DISCARDED → the queue drains.
-// Fully offline (local-only sessions) — which is itself a regression: retryDeadLetter/
-// absorbSalvage used to throw "no remote main" on a local-only holon (fixed with this test).
-@TestOn('vm')
-library;
-
-import 'dart:async';
-import 'dart:convert';
-import 'dart:io';
-
-import 'package:nomos_client/src/nms_conformance_runtime.dart';
-import 'package:test/test.dart';
-
-String get _root => '${Directory.current.path}/../..';
-String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.ts';
-String get _geoDeploy =>
-    '$_root/bench/scale/fixtures/estate-geo/build/estate-geo.law.usdz';
-String get _docsDeploy =>
-    '$_root/bench/scale/fixtures/surfaced/build/surfaced.law.usdz';
-String get _runtimeDir =>
-    Platform.environment['NOMOS_DART_RUNTIME'] ??
-    Platform.environment['NOMOS_OFFLINE_RUNTIME'] ??
-    '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
-
-String? _missingPrereq() {
-  if (!File(_repoEntry).existsSync())
-    return 'in-repo runner not found at $_repoEntry';
-  for (final e in {
-    _geoDeploy: 'bench/scale/fixtures/estate-geo',
-    _docsDeploy: 'bench/scale/fixtures/surfaced',
-  }.entries) {
-    if (!File(e.key).existsSync()) {
-      return 'missing fixture ${e.key} — compile it: (cd ${e.value} && node ../../../../dsl/compile_package.mjs)';
-    }
-  }
-  if (!File('$_runtimeDir/holon-testmint.wasm').existsSync() ||
-      !File('$_runtimeDir/bootstrap.law.usdz').existsSync() ||
-      !File('$_runtimeDir/nomos.law.usdz').existsSync()) {
-    return 'warm ~/.holon/runtime first (run any `githolon` command once)';
-  }
-  return null;
-}
-
-Future<T> _leg<T>(String name, Future<T> Function() body) async {
-  final sw = Stopwatch()..start();
-  // ignore: avoid_print
-  print('▶ DLQ $name …');
-  try {
-    final r = await body();
-    // ignore: avoid_print
-    print('✔ DLQ $name (${sw.elapsedMilliseconds}ms)');
-    return r;
-  } catch (e, st) {
-    throw TestFailure(
-        'DLQ $name FAILED after ${sw.elapsedMilliseconds}ms:\n$e\n$st');
-  }
-}
-
-void main() {
-  test(
-      'DLQ: park → surface → refused retry → law fix → retry admits → discard drains',
-      () async {
-    final missing = _missingPrereq();
-    if (missing != null) {
-      markTestSkipped(missing);
-      return;
-    }
-    final harness = await NomosTestHarness.cluster(
-      workspaces: {
-        'writer': [
-          _geoDeploy
-        ], // holds the estate law — where the work is authored
-        'app': [_docsDeploy], // the jammed workspace — NO estate law yet
-      },
-      nodeEntry: _repoEntry,
-      runtimeDir: _runtimeDir,
-      phaseTimeout: const Duration(seconds: 120),
-    );
-    try {
-      final writer = harness.session('writer');
-      final app = harness.session('app');
-      final geoHash = harness.lawHashes('writer').first;
-
-      // ── LEG 1: author REAL work under the estate law, and read its full intent bytes back
-      //    through the production salvage lane. ──
-      final work = await _leg(
-          'leg 1: author two writes + salvage their intent bytes', () async {
-        Future<void> place(String name) => writer.offerOutcome(
-              domain: 'estate',
-              directiveId: 'placeSite',
-              payload: {
-                'name': name,
-                'point': {
-                  'type': 'Point',
-                  'coordinates': [-2.24, 53.48]
-                },
-              },
-              actor: 'user:marta',
-              domainHash: geoHash,
-            );
-        await place('a day of work I refuse to lose');
-        await place('the second day');
-        final s = await writer.salvage();
-        final pending = ((s['pendingWrites'] as List?) ?? const [])
-            .whereType<Map>()
-            .map((m) => m.cast<String, Object?>())
-            .where((w) {
-          try {
-            final doc =
-                jsonDecode(utf8.decode(base64Decode(w['changeB64'].toString())))
-                    as Map;
-            return (doc['payload'] as Map?)?['domain'] == 'estate';
-          } catch (_) {
-            return false;
-          }
-        }).toList();
-        expect(pending, hasLength(2),
-            reason:
-                'salvage() returns the authored estate intents with their full bytes');
-        expect(pending.every((w) => (w['id'] ?? '').toString().isNotEmpty),
-            isTrue);
-        return pending;
-      });
-
-      // ── LEG 2: park both on the jammed workspace (the shape a domain rejection parks) and
-      //    assert deadLetters() surfaces them with full provenance. ──
-      await _leg(
-          'leg 2: park as dead letters → deadLetters() surfaces provenance',
-          () async {
-        final r = await app.absorbSalvage(deadLetters: [
-          for (final w in work)
-            {
-              'id': w['id'],
-              'oid': w[
-                  'id'], // provenance slot; the entry is deduped/looked up by id
-              'changeB64': w['changeB64'],
-              'source': 'local',
-              'error': "no active installed law declares domain 'estate'",
-            }
-        ]);
-        expect(r['requeuedDeadLetters'], 2);
-        final dead = await app.deadLetters();
-        expect(dead, hasLength(2));
-        final entry = dead.first;
-        expect(entry.domain, 'estate',
-            reason:
-                'the DLQ decodes domain/directiveId provenance from the parked bytes');
-        expect(entry.directive, 'placeSite');
-        expect(entry.source, 'local');
-      });
-
-      // ── LEG 3: retry while the law is still absent — a REFUSAL, not a loss (and, regression:
-      //    not a "no remote main" throw on this local-only session). ──
-      final firstId = work.first['id'].toString();
-      await _leg(
-          'leg 3: retry refuses while the law is absent; the entry stays',
-          () async {
-        final r = await app.retryDeadLetter(firstId);
-        expect(r.retried, isFalse, reason: 'the law still cannot merge it: $r');
-        final dead = await app.deadLetters();
-        expect(dead, hasLength(2),
-            reason: 'a refused retry NEVER drops the work');
-        expect(dead.firstWhere((d) => d.hasId() && d.id == firstId).message,
-            isNotEmpty,
-            reason: 'the entry carries the fresh refusal');
-      });
-
-      // ── LEG 4: the domain dev ships the law fix; retry UNJAMS and the work lands, readable. ──
-      await _leg(
-          'leg 4: law fix (installDomain) → retry admits → the work is on the ledger',
-          () async {
-        final usda = (jsonDecode(File(_geoDeploy).readAsStringSync())
-                as Map)['packageUsda']
-            .toString();
-        await app.offerOutcome(
-          domain: 'nomos',
-          directiveId: 'installDomain',
-          payload: {
-            'domainHash': geoHash,
-            'packageUsda': usda,
-            'installedBy': 'dlq-test-law-fix',
-            'dependencies': <Object?>[],
-            'finalizers': <Object?>[],
-          },
-          domainHash: harness.frameworkHash,
-        );
-        final r = await app.retryDeadLetter(firstId);
-        expect(r.retried, isTrue, reason: 'the unjam after the law fix: $r');
-        final dead = await app.deadLetters();
-        expect(dead, hasLength(1),
-            reason: 'the retried entry resolved out of the queue');
-        final rows = await app
-            .query('sitesByName', {'name': 'a day of work I refuse to lose'});
-        expect(rows, hasLength(1),
-            reason: "the user's work landed and reads back");
-      });
-
-      // ── LEG 5: discard is the app's explicit drop; the queue drains; a re-retry of a gone id
-      //    answers a typed refusal. ──
-      await _leg('leg 5: discard drains; retry of a gone id refuses by name',
-          () async {
-        final secondId = work[1]['id'].toString();
-        final d = await app.discardDeadLetter(secondId);
-        expect(d.removed, 1);
-        expect(await app.deadLetters(), isEmpty);
-        final gone = await app.retryDeadLetter(secondId);
-        expect(gone.retried, isFalse);
-        expect(gone.message, contains('no dead letter'));
-      });
-    } finally {
-      await harness.dispose().timeout(const Duration(seconds: 30),
-          onTimeout: () => throw StateError('harness disposal hung'));
-    }
-  }, timeout: const Timeout(Duration(minutes: 6)));
-}