@githolon/dsl 0.52.0 → 0.54.0

package/compat_package.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// NOMOS — Nomos Sovereign: participants act · verify · remember LOCALLY; hosted
+// remotes are replaceable custody/transport, not truth.  ⇒ ONE Nomos GitHolon
+// wasm32-wasip1 artifact {kernel · projection · embedded QuickJS engine}.
+// If a file isn't this / hosting this / authoring for this / proving this — it's gone.
+
+// `githolon compat` launcher — the twin of `compile_package.mjs`: resolve `tsx`
+// (the caller's, else the DSL's own dependency) and run `src/compat_package_main.ts`
+// under it (the main dynamically imports the caller's TS domain modules, which
+// needs the tsx ESM loader). Resolution goes through Node's resolver (createRequire),
+// NOT node_modules/.bin paths — hoisted/workspace installs put the bin shims elsewhere.
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const DSL_DIR = path.dirname(fileURLToPath(import.meta.url));
+const MAIN = path.join(DSL_DIR, "src", "compat_package_main.ts");
+
+function resolvePkgDir(name, fromDir) {
+  try {
+    const req = createRequire(pathToFileURL(path.join(fromDir, "noop.js")));
+    return path.dirname(req.resolve(`${name}/package.json`));
+  } catch {
+    return undefined;
+  }
+}
+
+const tsxDir = resolvePkgDir("tsx", process.cwd()) ?? resolvePkgDir("tsx", DSL_DIR);
+if (!tsxDir) {
+  console.error("githolon compat: tsx not found — reinstall @githolon/dsl (tsx is one of its dependencies)");
+  process.exit(1);
+}
+const tsxPkg = JSON.parse(readFileSync(path.join(tsxDir, "package.json"), "utf8"));
+const tsxBinRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.tsx;
+const tsxCli = path.join(tsxDir, tsxBinRel ?? "dist/cli.mjs");
+
+try {
+  execFileSync(process.execPath, [tsxCli, MAIN, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+  });
+} catch (e) {
+  process.exit(e.status ?? 1);
+}

package/dart/lib/src/webview_bridge.dart

@@ -276,21 +276,122 @@ class NomosCreated {
   String toString() => id;
 }
 
-/// A geographic bounding box for spatial reads (`[minLng, minLat] .. [maxLng, maxLat]`,
-/// RFC 7946 lng/lat order — the R*Tree probe's extent).
+/// A bounding box for spatial reads — the R*Tree probe's extent. Spatial is a GENERIC 2D index,
+/// so the CANONICAL axes are axis-neutral (`[minX, minY] .. [maxX, maxY]`); the axes' meaning
+/// (earth coordinates, floor-plan mm, anything) is the tenant's business. The original geographic
+/// `minLng`/`minLat`/`maxLng`/`maxLat` named params remain accepted forever (era rule) — pass either
+/// shape. On the wire `toJson()` emits BOTH key sets, so any holon runtime (old or new) reads it.
 class NomosBbox {
-  final double minLng;
-  final double minLat;
-  final double maxLng;
-  final double maxLat;
-  const NomosBbox({
-    required this.minLng,
-    required this.minLat,
-    required this.maxLng,
-    required this.maxLat,
+  final double minX;
+  final double minY;
+  final double maxX;
+  final double maxY;
+
+  /// Construct from either the canonical generic axes (`minX`/`minY`/`maxX`/`maxY`) OR the
+  /// geographic aliases (`minLng`/`minLat`/`maxLng`/`maxLat`). Provide exactly one shape per axis.
+  NomosBbox({
+    double? minX,
+    double? minY,
+    double? maxX,
+    double? maxY,
+    double? minLng,
+    double? minLat,
+    double? maxLng,
+    double? maxLat,
+  })  : minX = (minX ?? minLng)!,
+        minY = (minY ?? minLat)!,
+        maxX = (maxX ?? maxLng)!,
+        maxY = (maxY ?? maxLat)!;
+
+  /// Deprecated geographic accessors — spatial axes are generic. Prefer [minX]/[minY]/[maxX]/[maxY].
+  @Deprecated('Spatial axes are generic; use minX/minY. Kept for source compat.')
+  double get minLng => minX;
+  @Deprecated('Spatial axes are generic; use minX/minY. Kept for source compat.')
+  double get minLat => minY;
+  @Deprecated('Spatial axes are generic; use maxX/maxY. Kept for source compat.')
+  double get maxLng => maxX;
+  @Deprecated('Spatial axes are generic; use maxX/maxY. Kept for source compat.')
+  double get maxLat => maxY;
+
+  Map<String, Object?> toJson() => {
+        'minX': minX,
+        'minY': minY,
+        'maxX': maxX,
+        'maxY': maxY,
+        // Geographic aliases so a pre-genericisation runner (which reads minLng/…) still works.
+        'minLng': minX,
+        'minLat': minY,
+        'maxLng': maxX,
+        'maxLat': maxY,
+      };
+}
+
+/// One member's structural compat verdict — `ok`, plus the exact break [reason] when not.
+class NomosCompatMember {
+  final bool ok;
+  final String? reason;
+  const NomosCompatMember({required this.ok, this.reason});
+  factory NomosCompatMember.fromJson(Map<String, Object?> m) =>
+      NomosCompatMember(ok: m['ok'] == true, reason: m['reason'] as String?);
+}
+
+/// THE COMPAT SUPERPOWER verdict (#72b) — the Dart mirror of the JS `holon.compat`. Rolls the
+/// per-member structural verdicts up to a three-state [verdict], carries the deployed law's install
+/// phase, and exposes the dark-launch feature flag [has]. The pre-call refusal (a KNOWN-incompatible
+/// directive throwing [LawMismatchError]) lives in the JS runtime; this is the read surface the app
+/// branches on. Kept immutable + JSON-round-trippable so it crosses the bridge and unit-tests bare.
+class NomosCompat {
+  final String generatedFor;
+  final List<String> workspaceRuns;
+  final bool matches;
+  final bool offerKnown;
+  final bool? structurallyCompatible;
+
+  /// The three-state roll-up: `compatible` | `degraded` | `incompatible`.
+  final String verdict;
+
+  /// Each directive id (writes) / aggregate label (reads) → its own `{ ok, reason? }`.
+  final Map<String, NomosCompatMember> members;
+
+  /// The deployed law's lifecycle phase (Active / Superseded / Disabled / …) + the succeeding hash.
+  final String installPhase;
+  final String? supersededBy;
+
+  const NomosCompat({
+    required this.generatedFor,
+    required this.workspaceRuns,
+    required this.matches,
+    required this.offerKnown,
+    required this.structurallyCompatible,
+    required this.verdict,
+    required this.members,
+    required this.installPhase,
+    this.supersededBy,
   });
-  Map<String, Object?> toJson() =>
-      {'minLng': minLng, 'minLat': minLat, 'maxLng': maxLng, 'maxLat': maxLat};
+
+  /// THE FEATURE FLAG: true iff the member exists on the offer AND is structurally compatible.
+  bool has(String memberId) => members[memberId]?.ok == true;
+
+  static NomosCompat? fromJson(Map<String, Object?>? m) {
+    if (m == null) return null;
+    final rawMembers = (m['members'] as Map?)?.cast<String, Object?>() ?? const {};
+    final members = <String, NomosCompatMember>{};
+    rawMembers.forEach((k, v) {
+      if (v is Map) members[k] = NomosCompatMember.fromJson(v.cast<String, Object?>());
+    });
+    final install = (m['install'] as Map?)?.cast<String, Object?>() ?? const {};
+    return NomosCompat(
+      generatedFor: (m['generatedFor'] as String?) ?? '',
+      workspaceRuns: ((m['workspaceRuns'] as List?) ?? const []).map((e) => '$e').toList(),
+      matches: m['matches'] == true,
+      offerKnown: m['offerKnown'] == true,
+      structurallyCompatible: m['structurallyCompatible'] as bool?,
+      verdict: (m['verdict'] as String?) ?? 'degraded',
+      members: members,
+      installPhase: (install['phase'] as String?) ?? 'Unknown',
+      supersededBy: install['supersededBy'] as String?,
+    );
+  }
 }
 
 // ── E2E SEALING (the sealing client) — the GENERIC key-custody surface. Generated domain clients bake the
@@ -680,6 +781,10 @@ class NomosBridge {
   final Map<String, StreamController<List<dynamic>>> _watches = {};
   // SHAPE COMPATIBILITY (#72): compat bindings emit a verdict MAP, not a row list.
   final Map<String, StreamController<Map<String, Object?>>> _compatWatches = {};
+  // COMPAT SUPERPOWER (#72b): the last computed verdict + the live `lawChanged` event stream.
+  NomosCompat? _lastCompat;
+  final StreamController<NomosCompat> _lawChanged =
+      StreamController<NomosCompat>.broadcast();
   final StreamController<Map<String, Object?>> _syncEvents =
       StreamController<Map<String, Object?>>.broadcast();
   final StreamController<Map<String, Object?>> _signalEvents =
@@ -765,6 +870,16 @@ class NomosBridge {
       }
       return;
     }
+    if (event == 'lawChanged') {
+      // COMPAT SUPERPOWER (#72b): a synced install/upgrade/retire moved the workspace's offer under this
+      // live client. Cache the fresh verdict + emit it so the app re-checks feature flags without polling.
+      final c = NomosCompat.fromJson((m['compat'] as Map?)?.cast<String, Object?>());
+      if (c != null) {
+        _lastCompat = c;
+        if (!_lawChanged.isClosed) _lawChanged.add(c);
+      }
+      return;
+    }
     if (event == 'sync' || event == 'link') {
       // autoSync telemetry: each round { event:'sync', reason, result } and socket state { event:'link', status }.
       if (!_syncEvents.isClosed) _syncEvents.add(m);
@@ -1391,6 +1506,38 @@ class NomosBridge {
         if (offer != null) 'offer': offer,
       }));
 
+  /// THE COMPAT SUPERPOWER (#72b): compute the LIVE per-member verdict for this client's baked
+  /// [compat] manifest + structural [requirement] against the workspace's on-ledger offer. The
+  /// generated Dart client factory calls this at bind, so a KNOWN-incompatible directive refuses
+  /// CLIENT-SIDE at write time ([LawMismatchError] surfaced through `offerDirective`) — the JS
+  /// runtime holds the verdict + the pre-call guard, and a Dart offer through this bridge is guarded
+  /// too. Returns the verdict (also cached on [compat]) with per-member `{ ok, reason? }`.
+  Future<NomosCompat?> checkCompat(Map<String, Object?> compat,
+      [Map<String, Object?>? requirement]) async {
+    final r = _asMap(await _call('checkCompat', {
+      'compat': compat,
+      if (requirement != null) 'requirement': requirement,
+    }));
+    final v = NomosCompat.fromJson((r['compat'] as Map?)?.cast<String, Object?>());
+    if (v != null) _lastCompat = v;
+    return v;
+  }
+
+  /// The last computed compat verdict (set by [checkCompat] / a `lawChanged` event). Null until bind.
+  NomosCompat? get compat => _lastCompat;
+
+  /// THE FEATURE FLAG (dark-launch): true iff [member] exists on the workspace's offer AND is
+  /// structurally compatible. Ship UI with a member dark, deploy the law, it lights up — no redeploy.
+  /// Re-derives via the JS runtime so a synced law change is reflected without a fresh [checkCompat].
+  Future<bool> compatHas(String member) async {
+    final r = _asMap(await _call('compatHas', {'member': member}));
+    return r['has'] == true;
+  }
+
+  /// COMPAT SUPERPOWER live events: emits the fresh verdict whenever a synced install/upgrade/retire
+  /// moves the workspace's offer under this live client. The app re-checks feature flags reactively.
+  Stream<NomosCompat> get onLawChanged => _lawChanged.stream;
+
   /// SHAPE COMPATIBILITY as a LIVE BINDING (#72): a stream of verdicts that re-emits whenever the
   /// workspace's installed law changes (another peer installs/upgrades/retires a domain and it
   /// syncs in). The verdict carries `offerKnown`. The app degrades/prompts on `ok:false`.

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.33.0
+version: 0.34.0
 
 environment:
   sdk: ^3.5.0

package/dart/test/co2_acceptance_test.dart

@@ -0,0 +1,102 @@
+// THE CO2 ACCEPTANCE — DART LEG (task #32). Their feedback's Dart snippet, near-verbatim:
+// construct a rich nested DrawingGeoreference with typed constructors, dispatch it through the
+// generated client against REAL law on a local holon, and read BOTH aggregates back typed —
+// the primary georeference row AND the sibling EstateDrawing.transform write.
+@TestOn('vm')
+library;
+
+import 'dart:io';
+
+import 'package:nomos_client/nomos_headless.dart';
+import 'package:test/test.dart';
+
+import '../../../bench/scale/fixtures/co2-acceptance/build/dart/src/generated/estate.dart';
+import '../../../bench/scale/fixtures/co2-acceptance/build/dart/src/generated/estate.client.dart';
+
+String get _root => '${Directory.current.path}/../..';
+String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.mjs';
+String get _deployJson =>
+    '$_root/bench/scale/fixtures/co2-acceptance/build/co2-acceptance.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(_deployJson).existsSync()) {
+    return 'compile the fixture: cd bench/scale/fixtures/co2-acceptance && npx nomos-compile';
+  }
+  if (!File('$_runtimeDir/holon.wasm').existsSync() ||
+      !File('$_runtimeDir/packages.json').existsSync()) {
+    return 'warm ~/.holon/runtime first (run any `githolon` command once)';
+  }
+  return null;
+}
+
+void main() {
+  test('co2 acceptance: rich typed VO construction → multi-aggregate write → typed reads',
+      () async {
+    final skip = _missingPrereq();
+    if (skip != null) {
+      markTestSkipped(skip);
+      return;
+    }
+    final harness = await NomosTestHarness.ephemeral(
+      deployJsonPaths: [_deployJson],
+      nodeEntry: _repoEntry,
+      runtimeDir: _runtimeDir,
+      workspace: 'co2-acceptance',
+    );
+    try {
+      final estate = EstateClient(harness.bridge, actor: 'user:ada');
+
+      // Register a site whose location composes address + geo point (nested VOs).
+      await estate.registerSite(RegisterSitePayload(
+        name: 'Trafford Depot',
+        location: SiteLocation(
+          address: PostalAddress(
+              line1: '1 Wharf Rd', city: 'Manchester', postcode: 'M17 1AB', countryCode: 'GB'),
+          point: GeoPoint(coordinates: [-2.24, 53.48]),
+          source: SiteLocationSource.addressSearch,
+        ),
+        registeredAt: DateTime.now().toUtc().toIso8601String(),
+      ));
+      await estate.addDrawing(AddDrawingPayload(
+          title: 'Level 2 plan', addedAt: DateTime.now().toUtc().toIso8601String()));
+
+      final drawings = await estate.drawingsByTitle(title: 'Level 2 plan');
+      expect(drawings, hasLength(1));
+      final drawingId = drawings.single.aggregateId.value;
+      final sites = await estate.sitesByName(name: 'Trafford Depot');
+      expect(sites, hasLength(1));
+
+      // ── THEIR SNIPPET, VERBATIM SHAPE ──
+      await estate.recordDrawingGeoreference(RecordDrawingGeoreferencePayload(
+        drawingId: drawingId,
+        siteId: sites.single.aggregateId.value,
+        georeference: DrawingGeoreference(
+          transform: DrawingTransform2d(rotationDeg: 2.4),
+          controlPoints: [
+            DrawingGeoControlPoint(
+              drawingPosition: DrawingPositionMm(xMm: 1200, yMm: 800),
+              geoPoint: GeoPoint(coordinates: [-2.24, 53.48]),
+            ),
+          ],
+        ),
+        recordedAt: DateTime.now().toUtc().toIso8601String(),
+      ));
+
+      // Primary aggregate: the full nested VO reads back TYPED.
+      final georefs = await estate.georefsByDrawing(drawingId: drawingId);
+      expect(georefs, hasLength(1));
+      final g = georefs.single.georeference!;
+      expect(g.transform!.rotationDeg, 2.4);
+      expect(g.controlPoints.single.drawingPosition.xMm, 1200);
+      expect(g.controlPoints.single.geoPoint.coordinates.first, -2.24);
+
+      // THE SIBLING WRITE: EstateDrawing.transform got the VO subfield, typed.
+      final again = await estate.drawingsByTitle(title: 'Level 2 plan');
+      expect(again.single.transform!.rotationDeg, 2.4);
+    } finally {
+      await harness.dispose();
+    }
+  }, timeout: const Timeout(Duration(minutes: 3)));
+}

package/dart/test/compat_test.dart

@@ -0,0 +1,61 @@
+// 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/nomos_client.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/vo_read_typing_test.dart

@@ -0,0 +1,113 @@
+// RUNTIME PROOF (task #27) — read-side VO typing end-to-end. Install a REAL VO-bearing law
+// (nested VO + map-of-VO) into a fresh LOCAL holon, write one create through the real engine,
+// then read it back three ways — declared query, by-id, and a WATCH stream — parsing each
+// through the GENERATED read model and asserting TYPED nested + map-of-VO access
+// (`site.location!.point!.coordinates`, `site.rooms['a']!.address!.city`). No cloud, no network.
+//
+// Prereqs (skipped-with-reason when absent, so CI stays green): `node` on PATH; the in-repo
+// runner; a warm `~/.holon/runtime`; and the compiled fixture deploy.json + generated Dart
+// (`cd bench/scale/fixtures/vo-read-typing && npx nomos-compile`).
+@TestOn('vm')
+library;
+
+import 'dart:io';
+
+import 'package:nomos_client/nomos_client.dart';
+import 'package:nomos_client/nomos_headless.dart';
+import 'package:test/test.dart';
+
+// The fixture's GENERATED Dart read models (support: "package" → imports package:nomos_client).
+import '../../../bench/scale/fixtures/vo-read-typing/build/dart/src/generated/estate.dart';
+
+String get _root => '${Directory.current.path}/../..';
+String get _repoEntry => '$_root/cloud/web-client/runner/node-entry.mjs';
+String get _deployJson =>
+    '$_root/bench/scale/fixtures/vo-read-typing/build/vo-read-typing.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(_deployJson).existsSync()) {
+    return 'compile the fixture: cd bench/scale/fixtures/vo-read-typing && npx nomos-compile';
+  }
+  if (!File('$_runtimeDir/holon.wasm').existsSync() ||
+      !File('$_runtimeDir/packages.json').existsSync()) {
+    return 'warm ~/.holon/runtime first (run any `githolon` command once)';
+  }
+  return null;
+}
+
+void main() {
+  test('OFFLINE: nested VO + map-of-VO read back TYPED via query, by-id, and watch', () async {
+    final skip = _missingPrereq();
+    if (skip != null) {
+      markTestSkipped(skip);
+      return;
+    }
+    final harness = await NomosTestHarness.ephemeral(
+      deployJsonPaths: [_deployJson],
+      nodeEntry: _repoEntry,
+      runtimeDir: _runtimeDir,
+      registerTearDown: addTearDown,
+    );
+
+    // Author one Site through the REAL law: a nested VO `location` + a map-of-VO `rooms`.
+    final outcome = await harness.bridge.offerCreates(
+      domain: 'estate',
+      directiveId: 'placeSite',
+      payload: {
+        'name': 'HQ',
+        'location': {
+          'address': {'streetAddress': '1 High St', 'city': 'Leeds'},
+          'point': {'type': 'Point', 'coordinates': [-1.55, 53.8]},
+        },
+        'rooms': {
+          'atrium': {
+            'address': {'streetAddress': '1 High St', 'city': 'Leeds'},
+            'point': {'type': 'Point', 'coordinates': [-1.5, 53.79]},
+          },
+        },
+      },
+    );
+    expect(outcome.created, hasLength(1));
+    final siteId = SiteId.fromRow(outcome.created.single.id);
+
+    // ── (1) declared query → typed Site, typed nested VO + typed map-of-VO ──
+    final qRows = await harness.bridge.query('sitesByName', {'name': 'HQ'});
+    expect(qRows, hasLength(1));
+    final fromQuery =
+        Site.fromJson((qRows.first['data'] as Map).cast<String, dynamic>(), (qRows.first['id'] ?? '').toString());
+
+    expect(fromQuery.name, 'HQ');
+    // Typed nested VO access — no map indexing, no casts.
+    expect(fromQuery.location, isA<SiteLocation>());
+    expect(fromQuery.location!.point, isA<GeoPoint>());
+    expect(fromQuery.location!.point!.coordinates, [-1.55, 53.8]);
+    expect(fromQuery.location!.address!.city, 'Leeds');
+    // Typed map-of-VO access: rooms is Map<String, SiteLocation>, NOT a raw map.
+    expect(fromQuery.rooms, isA<Map<String, SiteLocation>>());
+    expect(fromQuery.rooms['atrium'], isA<SiteLocation>());
+    expect(fromQuery.rooms['atrium']!.point!.coordinates, [-1.5, 53.79]);
+    expect(fromQuery.rooms['atrium']!.address!.city, 'Leeds');
+
+    // ── (2) by-id read → same typed shape ──
+    final byIdRows = await harness.bridge.queryById(siteId.value);
+    expect(byIdRows, hasLength(1));
+    final fromById =
+        Site.fromJson((byIdRows.first['data'] as Map).cast<String, dynamic>(), (byIdRows.first['id'] ?? '').toString());
+    expect(fromById.location!.point!.coordinates, [-1.55, 53.8]);
+    expect(fromById.rooms['atrium']!.point!.coordinates, [-1.5, 53.79]);
+
+    // ── (3) watch stream → typed rows, identical decode ──
+    final watched = await harness.bridge
+        .watchById(siteId.value)
+        .map((rows) => rows
+            .map((r) => Site.fromJson((r['data'] as Map).cast<String, dynamic>(), (r['id'] ?? '').toString()))
+            .toList())
+        .firstWhere((rows) => rows.isNotEmpty);
+    expect(watched, hasLength(1));
+    final fromWatch = watched.single;
+    expect(fromWatch.location!.point!.coordinates, [-1.55, 53.8]);
+    expect(fromWatch.rooms['atrium']!.address!.city, 'Leeds');
+  }, timeout: const Timeout(Duration(minutes: 2)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.52.0",
+  "version": "0.54.0",
   "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",
@@ -48,6 +48,7 @@
     "!dart/build",
     "compile_package.mjs",
     "check_package.mjs",
+    "compat_package.mjs",
     "lsp_server.mjs"
   ],
   "publishConfig": {