@githolon/dsl 0.57.0 → 0.57.1

package/dart/lib/src/test_harness.dart

@@ -190,7 +190,13 @@ class NomosTestHarness {
         allowUnborn: true,
       );
       final harness = NomosTestHarness._(
-          bridge, workspace, transport, workdir, onDiagnostic, [workspace]);
+          bridge, workspace, transport, workdir, onDiagnostic, [workspace],
+          frameworkHash: info['frameworkHash']?.toString(),
+          lawHashes: {
+            workspace: ((info['lawHashes'] as List?) ?? const [])
+                .map((e) => e.toString())
+                .toList()
+          });
       if (autoTearDown && registerTearDown != null) {
         registerTearDown(harness.dispose);
       }
@@ -259,9 +265,11 @@ class NomosTestHarness {
     try {
       // 1. install each workspace's law offline → one snapshot per workspace (colocated, still separate law).
       final snapshots = <String, String>{};
+      final lawHashesByWs = <String, List<String>>{};
+      String? frameworkHash;
       for (final e in workspaces.entries) {
         final snap = '${workdir.path}/${e.key}.bin';
-        await _runInstall(
+        final info = await _runInstall(
             node: node,
             useInRepoScript: useInRepoScript,
             inRepoScript: resolvedHelper,
@@ -272,6 +280,10 @@ class NomosTestHarness {
             runtimeDir: runtimeDir,
             onDiagnostic: onDiagnostic);
         snapshots[e.key] = snap;
+        lawHashesByWs[e.key] = ((info['lawHashes'] as List?) ?? const [])
+            .map((x) => x.toString())
+            .toList();
+        frameworkHash ??= info['frameworkHash']?.toString();
       }
 
       // 2. ONE runner / ONE bridge for the whole plane — no env restore default; each connect brings its own.
@@ -324,7 +336,9 @@ class NomosTestHarness {
       final names = workspaces.keys.toList();
       final harness = NomosTestHarness._(
           bridge, names.first, transport, workdir, onDiagnostic, names,
-          devicePublics);
+          devicePublics: devicePublics,
+          frameworkHash: frameworkHash,
+          lawHashes: lawHashesByWs);
       if (autoTearDown && registerTearDown != null) {
         registerTearDown(harness.dispose);
       }

package/dart/lib/src/webview_bridge.dart

@@ -1127,14 +1127,18 @@ class NomosBridge {
         .whereType<Map>()
         .map((m) => m.cast<String, Object?>())
         .toList();
+    // `born` elements may be plain workspace-name strings OR `{workspace,…}` objects (both shapes ship);
+    // fall back to the birth outcomes' workspace names when no bare `born` list was sent.
+    final bornRaw = (r['born'] as List?);
     final bornNames = <String>[
-      ...((r['born'] as List?) ?? const []).map((e) => e.toString()),
-      // Fall back to the workspace field of each birth outcome when a bare `born` list wasn't sent.
-      if ((r['born'] as List?) == null)
+      if (bornRaw != null)
+        ...bornRaw.map((e) =>
+            (e is Map ? (e['workspace'] ?? '') : e).toString())
+      else
         ...births
             .map((m) => (m['workspace'] ?? '').toString())
             .where((s) => s.isNotEmpty),
-    ];
+    ]..removeWhere((s) => s.isEmpty);
     return NomosOfferOutcome(
       head: r['head'].toString(),
       created: ((r['created'] as List?) ?? const [])

package/dart/test/cluster_births_test.dart

@@ -0,0 +1,146 @@
+// LOCAL BIRTHS — DART LEG. An offline `.births()` directive dispatch: the estate-birth `home` law's
+// `birthEstateWorkspace` OFFERS a birth on THIS device's local plane — no cloud. Three things are proven:
+//
+//   1. THE DART API PATH: the offer surfaces the typed birth verdict — `born` (the child workspace name) +
+//      `birthOutcomes` (the per-child fate) — off NomosOfferOutcome. A birth is observable from Dart.
+//   2. THE OFFLINE BIRTH SUCCEEDS (status=born): the child genesis (installDomain×2 + seed) folds through the
+//      CHILD's own gate, fully offline. This needed a lane fix — the client holon's wasm provider now stages
+//      the stage-0 bootstrap package at the preopen root (`/work/domain.package.usda`), the SAME file the
+//      adapter engine stages, which `run_birth_effect` reads as the genesis-lane executor for the child's
+//      step-0 `bootstrap/installDomain`. Without it the birth failed with "bare JavaScript is not a domain
+//      package" (see cloud/web-client/src/kernel_provider_wasm.mjs boot).
+//   3. A FAILED birth carries a TYPED reason to Dart (deliberate bad framework hash) — never a silent drop.
+//
+// THE NAMED GAP (task #42): opening the born child as a SIBLING SESSION (`bridge.session(child)` → typed
+// query) requires the SHARED ENGINE PLANE — today each runner session is its own single-workspace engine, so
+// a sibling session can't see the child custody born in another. We do NOT fake that loop; the child handle
+// is addressable, and we stop there.
+@TestOn('vm')
+library;
+
+import 'dart:io';
+
+import 'package:nomos_client/nomos_client.dart' show NomosOfferOutcome;
+import 'package:nomos_client/nomos_headless.dart';
+import 'package:test/test.dart';
+
+String get _root => '${Directory.current.path}/../..';
+String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.mjs';
+String get _birthDeploy =>
+    '$_root/bench/scale/fixtures/estate-birth/build/estate-birth.deploy.json';
+String get _runtimeDir => '${Platform.environment['HOME'] ?? ''}/.holon/runtime';
+
+String? _missingPrereq() {
+  if (!File(_repoEntry).existsSync()) return 'in-repo runner not found at $_repoEntry';
+  if (!File(_birthDeploy).existsSync()) {
+    return 'compile the fixture: cd bench/scale/fixtures/estate-birth && node ../../../../dsl/compile_package.mjs — missing $_birthDeploy';
+  }
+  if (!File('$_runtimeDir/holon.wasm').existsSync() ||
+      !File('$_runtimeDir/packages.json').existsSync()) {
+    return 'warm ~/.holon/runtime first (run any `githolon` command once)';
+  }
+  return null;
+}
+
+const _owner = 'sample-owner';
+
+/// Set up a single-session plane over the estate-birth law + OFFER `birthEstateWorkspace` on it. Returns the
+/// harness (for teardown) + the offer outcome (born / birthOutcomes surfaced). [frameworkHash] overrides the
+/// real framework hash (pass a bogus one to force a genesis failure).
+Future<(NomosTestHarness, NomosOfferOutcome)> _birth({String? frameworkHash}) async {
+  final harness = await NomosTestHarness.ephemeral(
+    deployJsonPaths: [_birthDeploy],
+    nodeEntry: _repoEntry,
+    runtimeDir: _runtimeDir,
+    workspace: 'estate-birth',
+  );
+  // The genesis recipe installs the framework + child law BY HASH — the harness surfaces both (frameworkHash
+  // is not derivable client-side; lawHash is this package's own domainHash).
+  final fw = frameworkHash ?? harness.frameworkHash;
+  final lawHash = harness.lawHashes('estate-birth').first;
+  final outcome = await harness.bridge.offerCreates(
+    domain: 'home',
+    directiveId: 'birthEstateWorkspace',
+    payload: {
+      'owner': _owner,
+      'frameworkHash': fw,
+      'lawHash': lawHash,
+      'bornAt': '2026-07-05T00:00:00Z',
+    },
+    actor: _owner,
+  );
+  return (harness, outcome);
+}
+
+void main() {
+  test('offline .births() dispatch surfaces born + birthOutcomes TYPED to Dart', () async {
+    final skip = _missingPrereq();
+    if (skip != null) {
+      markTestSkipped(skip);
+      return;
+    }
+    final (harness, outcome) = await _birth();
+    try {
+      expect(outcome.head, isNotEmpty,
+          reason: 'the birth offer admitted on the local plane');
+      // THE API PATH (co2's ask): the birth verdict is typed back to Dart.
+      expect(outcome.born, isNotEmpty,
+          reason: 'the offer-effect allocated the estate child workspace on the local plane');
+      expect(outcome.born.single, startsWith('estate-'),
+          reason: 'the born workspace is estate-<sha256(owner)>');
+      expect(outcome.birthOutcomes, isNotEmpty,
+          reason: 'the typed birth verdict rides beside born');
+      expect(outcome.birthOutcomes.first['workspace'], outcome.born.single);
+      expect(outcome.birthOutcomes.first['status'], isNotNull);
+
+      // NAMED GAP (#42): the child handle is addressable on the plane, but opening it as its own session
+      // across the runner's per-session engines needs the shared engine plane — we stop at the handle.
+      expect(harness.bridge.session(outcome.born.single).workspace, outcome.born.single);
+    } finally {
+      await harness.dispose();
+    }
+  }, timeout: const Timeout(Duration(minutes: 3)));
+
+  test('offline birth genesis SUCCEEDS (status=born) — the child is folded through its own gate', () async {
+    final skip = _missingPrereq();
+    if (skip != null) {
+      markTestSkipped(skip);
+      return;
+    }
+    final (harness, outcome) = await _birth();
+    try {
+      // The lane is fixed (the provider stages the stage-0 bootstrap package at the preopen root), so the
+      // child genesis folds clean and the born verdict is `born` — hard-asserted, no skip.
+      expect(outcome.born, hasLength(1));
+      expect(outcome.birthOutcomes, hasLength(1));
+      expect(outcome.birthOutcomes.first['status'], 'born',
+          reason: 'the child genesis (installDomain×2 + seed) folded through the child\'s own gate offline');
+      expect(outcome.birthOutcomes.first['workspace'], outcome.born.single);
+    } finally {
+      await harness.dispose();
+    }
+  }, timeout: const Timeout(Duration(minutes: 3)));
+
+  test('birth FAILURE carries a typed reason to Dart (deliberate bad framework hash)', () async {
+    final skip = _missingPrereq();
+    if (skip != null) {
+      markTestSkipped(skip);
+      return;
+    }
+    // A well-formed but WRONG framework hash the parent does not fold → the child's step-0 install can't be
+    // satisfied → the genesis fold refuses. The offer still admits on the parent (the birth ORDER is valid);
+    // the child's fate comes back as a TYPED failure outcome, not a thrown error or a silent drop.
+    final badHash = 'deadbeef' * 8; // 64 hex chars, not a package the parent holds
+    final (harness, outcome) = await _birth(frameworkHash: badHash);
+    try {
+      expect(outcome.birthOutcomes, isNotEmpty,
+          reason: 'a failed birth still reports its typed verdict to Dart');
+      expect(outcome.birthOutcomes.first['status'], isNot('born'),
+          reason: 'an unresolvable framework hash cannot yield a born child');
+      expect((outcome.birthOutcomes.first['reason'] ?? '').toString(), isNotEmpty,
+          reason: 'the failure carries a human-legible reason (never a silent drop)');
+    } finally {
+      await harness.dispose();
+    }
+  }, timeout: const Timeout(Duration(minutes: 3)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.57.0",
+  "version": "0.57.1",
   "type": "module",
   "description": "Nomos 2 domain-authoring DSL: aggregates + directives in TS, executed and encoded to the Rust kernel's wire shapes.",
   "license": "SEE LICENSE IN LICENSE.md",