@githolon/dsl 0.103.0 → 0.103.1

package/dart/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.64.3
+
+- Single-flight generated child-workspace acquisition and continuous sync so concurrent references share one
+  open, one lifecycle result and one error rather than cloning or registering the same workspace twice.
+- Generate separate shared-workspace reads so applications can render denormalized owned-workspace cards
+  without eagerly opening every founded child merely to discover genuinely shared lives.
+
 ## 0.64.2
 
 - Execute generated applications through the typed USDA-native kernel boundary, including native read

package/dart/lib/src/runner/node-entry.mjs

@@ -16,6 +16,43 @@ var RUNNER_BUNDLE_VERSION = typeof __NOMOS_BUNDLE_VERSION__ !== "undefined" ? __
 var plainObject = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : null;
 var errorMessage = (e, fallback = "nomos runtime error") => String(e?.message ?? e ?? fallback);
 var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0 && v !== null && v !== ""));
+var PERF_COMPONENT_LIMIT = 12;
+var PERF_PHASE_LIMIT = 16;
+var PERF_NOTE_LIMIT = 12;
+var numericEntries = (value, limit) => {
+  const entries = Object.entries(plainObject(value) || {}).filter(([, v]) => typeof v === "number" && Number.isFinite(v) && v !== 0).map(([name, n]) => [name, n]).sort((a, b) => Math.abs(b[1]) - Math.abs(a[1]));
+  return {
+    values: Object.fromEntries(entries.slice(0, limit)),
+    omitted: Math.max(0, entries.length - limit)
+  };
+};
+function boundedKernelSpans(value) {
+  const root = plainObject(value);
+  if (!root) return value;
+  const ranked = Object.entries(root).map(([name, raw]) => {
+    const row = plainObject(raw) || {};
+    const phases = numericEntries(row.phases, PERF_PHASE_LIMIT);
+    const notes = numericEntries(row.notes, PERF_NOTE_LIMIT);
+    const flat = numericEntries(row, PERF_PHASE_LIMIT);
+    const totalUs = typeof row.totalUs === "number" && Number.isFinite(row.totalUs) ? row.totalUs : Object.values(flat.values).reduce((sum, n) => sum + Number(n), 0);
+    const shaped = plainObject(row.phases) || plainObject(row.notes) || row.totalUs !== void 0 ? compact({
+      totalUs,
+      phases: Object.keys(phases.values).length ? phases.values : void 0,
+      notes: Object.keys(notes.values).length ? notes.values : void 0,
+      omittedPhases: phases.omitted || void 0,
+      omittedNotes: notes.omitted || void 0
+    }) : compact({
+      ...flat.values,
+      omittedMetrics: flat.omitted || void 0
+    });
+    return { name, totalUs, shaped };
+  }).sort((a, b) => b.totalUs - a.totalUs);
+  const kept = ranked.slice(0, PERF_COMPONENT_LIMIT);
+  return {
+    ...Object.fromEntries(kept.map(({ name, shaped }) => [name, shaped])),
+    ...ranked.length > PERF_COMPONENT_LIMIT ? { _summary: { omittedComponents: ranked.length - PERF_COMPONENT_LIMIT } } : {}
+  };
+}
 var errorInfo = (e, req = {}, component = "nomos.webview.runner") => {
   const err = e;
   const existing = plainObject(err?.errorInfo) || plainObject(err?.info);
@@ -99,6 +136,7 @@ function createWebviewRunner({ post: post2, openRealm: openRealm2 }) {
   const spanStarts = /* @__PURE__ */ new Map();
   const forwardSpan = (session, raw) => {
     const s = plainObject(raw) ?? {};
+    const presented = s.kernelSpans === void 0 ? s : { ...s, kernelSpans: boundedKernelSpans(s.kernelSpans) };
     const id = String(s.id ?? "");
     if (s.phase === "begin" && id) {
       spanStarts.set(id, s);
@@ -115,13 +153,13 @@ function createWebviewRunner({ post: post2, openRealm: openRealm2 }) {
           elapsedMs,
           domain: s.domain,
           directiveId: s.directiveId,
-          kernelSpans: s.kernelSpans,
+          kernelSpans: presented.kernelSpans,
           born: s.born,
           birthOutcomes: s.birthOutcomes
         }))}`);
       }
     }
-    post2({ v: WEBVIEW_BRIDGE_VERSION, event: "span", session, span: raw });
+    post2({ v: WEBVIEW_BRIDGE_VERSION, event: "span", session, span: presented });
   };
   const pendingCustodyAsks = /* @__PURE__ */ new Map();
   let connectGate = Promise.resolve();
@@ -566,7 +604,12 @@ function createWebviewRunner({ post: post2, openRealm: openRealm2 }) {
       return await (await need(a)).__nomosPrepareOwnedRecordAction({ action: a.action, scope: a.scope, record: a.record, peer: a.peer });
     },
     async cryptoOwnedBirthScopeKey(a) {
-      return await (await need(a)).__nomosOwnedBirthScopeKey({ scope: a.scope, namespace: a.namespace, key: a.key, record: a.record });
+      return await (await need(a)).__nomosOwnedBirthScopeKey({
+        scope: a.scope,
+        namespace: a.namespace,
+        key: a.key,
+        ...a.record !== void 0 ? { record: a.record } : {}
+      });
     },
     async cryptoOwnedDeviceRequest(a) {
       return { request: await (await need(a)).__nomosOwnedDeviceRequest({ scope: a.scope }) };

package/dart/lib/src/webview_bridge.dart

@@ -1039,6 +1039,11 @@ class NomosBridge {
   // [acquireSession]'s per-workspace single-flight: workspace → the in-flight open every concurrent
   // acquirer joins (removed when it completes; a live session then hits the fast path instead).
   final Map<String, Future<NomosSession>> _acquiring = {};
+  // Every workspace opened as part of one stateful application participates in continuous custody exchange.
+  // Starting that lifecycle is itself single-flight: generated navigation may discover the same child through
+  // several references, but the runner gets one autoSync registration for that session.
+  final Set<String> _autoSyncSessions = {};
+  final Map<String, Future<void>> _autoSyncStarting = {};
   int _seq = 0;
   final String _traceId = _newTraceId();
   late final StreamSubscription<Map<String, Object?>> _sub;
@@ -1875,14 +1880,34 @@ class NomosBridge {
       plane._sessionPrincipals[workspace] = sourcePrincipal;
     }
 
+    Future<NomosSession> ready(NomosSession opened) async {
+      inheritPrincipal();
+      if (!plane._autoSyncSessions.contains(workspace)) {
+        final start = plane._autoSyncStarting.putIfAbsent(workspace, () async {
+          await opened.autoSync();
+          plane._autoSyncSessions.add(workspace);
+        });
+        try {
+          await start;
+        } finally {
+          if (identical(plane._autoSyncStarting[workspace], start)) {
+            plane._autoSyncStarting.remove(workspace);
+          }
+        }
+      }
+      return opened;
+    }
+
     if (plane._sessionNames.contains(workspace)) {
       inheritPrincipal();
-      return Future.value(session(workspace));
+      return ready(session(workspace));
     }
     // SINGLE-FLIGHT: one in-flight open per workspace per plane; concurrent callers join it.
     return plane._acquiring.putIfAbsent(workspace, () async {
       try {
-        if (plane._sessionNames.contains(workspace)) return session(workspace);
+        if (plane._sessionNames.contains(workspace)) {
+          return ready(session(workspace));
+        }
         // Consult the plane's TRUTHFUL registry (mounted ∪ parked ∪ resident custody — the runner's
         // realm.list()): anything the device already holds opens locally, no cloud, no credentials.
         var resident = false;
@@ -1898,8 +1923,7 @@ class NomosBridge {
               session: workspace,
               allowUnborn: true,
               authorSecret: authorSecret);
-          inheritPrincipal();
-          return session(workspace);
+          return ready(session(workspace));
         }
         if (ifAbsentCredentials == null) {
           throw StateError(
@@ -1916,8 +1940,7 @@ class NomosBridge {
           authorSecret: c.authorSecret ?? authorSecret,
           allowUnborn: c.allowUnborn,
         );
-        inheritPrincipal();
-        return session(workspace);
+        return ready(session(workspace));
       } finally {
         // completed (either way) — the next acquire re-evaluates fresh (a live session hits the fast path).
         plane._acquiring.remove(workspace);
@@ -1935,11 +1958,12 @@ class NomosBridge {
   /// @internal The immutable genesis of a sibling custody chain. This is observational metadata used to
   /// compose an ordinary source-enrolment offer; the kernel still reopens and proves every foreign read.
   Future<String> nomosWorkspaceGenesis(String workspace,
-      {String? session}) async =>
+          {String? session}) async =>
       (_asMap(await _call('nomosWorkspaceGenesis', {
-        'workspace': workspace,
-        if (session != null) 'session': session,
-      }))['genesis'] ?? '')
+                'workspace': workspace,
+                if (session != null) 'session': session,
+              }))['genesis'] ??
+              '')
           .toString();
 
   /// UNDO the most-recent action via the kernel STRIKE primitive (the fold drops the struck intent by parity).
@@ -2452,7 +2476,8 @@ class NomosBridge {
   /// Compare an immutable publication pin with the stable series' one compiled
   /// current pointer. This is an O(current-state) check: it neither resolves the
   /// pinned publication nor reconstructs aggregate history.
-  Future<ReferenceFreshness<TVersion>> checkReferenceFreshness<TVersion, TSeries>(
+  Future<ReferenceFreshness<TVersion>>
+      checkReferenceFreshness<TVersion, TSeries>(
     VersionedNomosRef<TVersion, TSeries> reference,
   ) async {
     final result = _asMap(await _call('checkRefFreshness', {
@@ -2460,8 +2485,7 @@ class NomosBridge {
         {
           'pinned': NmsInternalNomosRefs.toJson(reference.pinned),
           'series': NmsInternalNomosRefs.toJson(reference.series),
-          'currentField':
-              NmsInternalVersionedNomosRefs.currentField(reference),
+          'currentField': NmsInternalVersionedNomosRefs.currentField(reference),
         },
       ],
     }));
@@ -2666,8 +2690,8 @@ class NomosBridge {
       }));
 
   /// FRAMEWORK-INTERNAL business birth: derive the unborn child's owned key from its deterministic address.
-  Future<NomosScopeKey> nomosOwnedBirthScopeKey(
-      String scope, String namespace, Object? key, String recordType, String recordId) async {
+  Future<NomosScopeKey> nomosOwnedBirthScopeKey(String scope, String namespace,
+      Object? key, String recordType, String recordId) async {
     final out = _asMap(await _call('cryptoOwnedBirthScopeKey', {
       'scope': scope,
       'namespace': namespace,
@@ -2799,14 +2823,20 @@ class NomosBridge {
   /// Each round arrives on [syncEvents] as `{ event:'sync', reason, result }`; socket state as `{event:'link'}`.
   /// Call once after [connect] — then the app never polls.
   Future<void> autoSync(
-          {int? debounceMs, int? fallbackMs, String? signalId}) async =>
-      await _call('autoSync', {
-        if (debounceMs != null) 'debounceMs': debounceMs,
-        if (fallbackMs != null) 'fallbackMs': fallbackMs,
-        if (signalId != null) 'signalId': signalId
-      });
+      {int? debounceMs, int? fallbackMs, String? signalId}) async {
+    await _call('autoSync', {
+      if (debounceMs != null) 'debounceMs': debounceMs,
+      if (fallbackMs != null) 'fallbackMs': fallbackMs,
+      if (signalId != null) 'signalId': signalId
+    });
+    final workspace = _sessionName;
+    if (workspace != null) _eventPlane._autoSyncSessions.add(workspace);
+  }
+
   Future<void> stopAutoSync() async {
     await _call('stopAutoSync');
+    final workspace = _sessionName;
+    if (workspace != null) _eventPlane._autoSyncSessions.remove(workspace);
   }
 
   /// Background-sync telemetry: each autoSync round (`event:'sync'`) and doorbell socket state (`event:'link'`).

package/dart/pubspec.yaml

@@ -8,7 +8,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.64.2
+version: 0.64.3
 
 environment:
   sdk: ^3.5.0

package/dart/test/acquire_session_test.dart

@@ -25,6 +25,11 @@ class FakeRunner implements BridgeTransport {
   }
 
   int get connectCount => sent.where((m) => m['op'] == 'connect').length;
+  int autoSyncCount(String workspace) => sent
+      .where((m) =>
+          m['op'] == 'autoSync' &&
+          ((m['args'] as Map)['session']).toString() == workspace)
+      .length;
   Map<String, Object?> connectArgs(int i) =>
       (sent.where((m) => m['op'] == 'connect').elementAt(i)['args'] as Map)
           .cast<String, Object?>();
@@ -89,6 +94,8 @@ void main() {
             fail('credentials must not be requested for a mounted session'));
     expect(identical(s, bridge.session('home')), isTrue);
     expect(runner.connectCount, 1, reason: 'no re-connect for a live session');
+    expect(runner.autoSyncCount('home'), 1,
+        reason: 'an acquired application workspace continuously syncs');
     await bridge.dispose();
   });
 
@@ -140,6 +147,8 @@ void main() {
         reason: 'ONE connect for three concurrent acquires');
     expect(identical(results[0], results[1]), isTrue);
     expect(identical(results[1], results[2]), isTrue);
+    expect(runner.autoSyncCount('cloudy'), 1,
+        reason: 'the workspace lifecycle is single-flight too');
     final args = runner.connectArgs(0);
     expect(args['cloud'], 'https://cloud.example');
     expect(args['authToken'], 'tok');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.103.0",
+  "version": "0.103.1",
   "type": "module",
   "sideEffects": false,
   "description": "Nomos 2 domain-authoring DSL: aggregates + directives in TS, executed and encoded to the Rust kernel's wire shapes.",

package/src/codegen_dart_application.ts

@@ -1168,6 +1168,18 @@ export function generateDartApplication(
           `    for (final record in records) {`,
           `      seen.add(NmsInternalRecordOrigins.require(record).workspace);`,
           `    }`,
+          `    for (final record in await shared()) {`,
+          `      final workspace = NmsInternalRecordOrigins.require(record).workspace;`,
+          `      if (seen.add(workspace)) records.add(record);`,
+          `    }`,
+          `    return records;`,
+          `  }`,
+          ``,
+          `  /// The ${birth.aggregateId} lives shared with the signed-in person.`,
+          `  /// Unlike [available], this does not open lives founded by that person.`,
+          `  Future<List<${rootModel}>> shared() async {`,
+          `    final records = <${rootModel}>[];`,
+          `    final seen = <String>{};`,
           `    final shares = await _client.bridge.query('sharedByObject', {'object': 'workspace:self'}, null, _client.actor);`,
           `    for (final row in shares) {`,
           `      final raw = row['data'];`,
@@ -1191,6 +1203,12 @@ export function generateDartApplication(
           `    return records;`,
           `  }`,
           ``,
+          `  /// React when this person's shared ${birth.aggregateId} lives change.`,
+          `  Stream<List<${rootModel}>> watchShared() =>`,
+          `      _client.bridge`,
+          `          .watch('sharedByObject', {'object': 'workspace:self'}, null, _client.actor, 60000)`,
+          `          .asyncMap((_) => shared());`,
+          ``,
           `  /// React when this person's available ${birth.aggregateId} lives change.`,
           `  Stream<List<${rootModel}>> watchAvailable() =>`,
           `      Stream<List<${rootModel}>>.multi((events) {`,

package/src/compile_package_main.ts

@@ -1603,8 +1603,8 @@ const NOMOS_TYPES_DEP = "^0.8.0";
 // 0.48.x: session-bound clients (XClient.bind/NomosClientInterface/DomainClientSessionMismatch/
 //         DomainNotInstalledForSession, engine.follow, pendingConflicts lanes) — the generated client
 //         REQUIRES this surface. 0.48.1 fixes NomosSession.watchPendingConflicts delegation.
-const NOMOS_CLIENT_DEP = "^0.64.1";
-const NOMOS_FLUTTER_DEP = "^0.63.1";
+const NOMOS_CLIENT_DEP = "^0.64.3";
+const NOMOS_FLUTTER_DEP = "^0.63.4";
 // DRIFT TRIPWIRE: pubspec_pins.test.ts asserts these equal the CURRENT versions in dsl/dart/pubspec.yaml
 // and dsl/dart_types/pubspec.yaml — a Dart release without this bump fails the suite, so tenants never
 // land back in dependency_overrides (the exact co2 report this closes, third occurrence).