@githolon/dsl 0.101.6 → 0.102.1

package/dart/test/acquire_session_test.dart

@@ -5,7 +5,7 @@
 // cluster_local_autosync_test.dart.
 import 'dart:async';
 
-import 'package:nomos_client/nomos_client.dart';
+import 'package:nomos_client/src/nms_generated_runtime.dart';
 import 'package:test/test.dart';
 
 /// A fake runner: answers connect (after a real async gap, so concurrency is observable) and
@@ -13,11 +13,15 @@ import 'package:test/test.dart';
 class FakeRunner implements BridgeTransport {
   final _incoming = StreamController<Map<String, Object?>>.broadcast();
   final List<Map<String, Object?>> sent = [];
-  final List<String> resident; // workspaces the plane already holds (realm.list())
+  final List<String>
+      resident; // workspaces the plane already holds (realm.list())
 
   FakeRunner({this.resident = const []}) {
-    scheduleMicrotask(
-        () => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'ready', 'bundleVersion': 'unbundled-dev'}));
+    scheduleMicrotask(() => _incoming.add({
+          'v': kWebviewBridgeVersion,
+          'event': 'ready',
+          'bundleVersion': 'unbundled-dev'
+        }));
   }
 
   int get connectCount => sent.where((m) => m['op'] == 'connect').length;
@@ -64,14 +68,16 @@ class FakeRunner implements BridgeTransport {
         default:
           result = {};
       }
-      _incoming
-          .add({'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result});
+      _incoming.add(
+          {'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result});
     });
   }
 }
 
 void main() {
-  test('an already-connected session is reused — credentials NEVER invoked, no second connect', () async {
+  test(
+      'an already-connected session is reused — credentials NEVER invoked, no second connect',
+      () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
     await bridge.ready;
@@ -86,17 +92,21 @@ void main() {
     await bridge.dispose();
   });
 
-  test('a plane-resident (parked) workspace opens LOCALLY — no cloud, credentials NOT invoked', () async {
+  test(
+      'a plane-resident (parked) workspace opens LOCALLY — no cloud, credentials NOT invoked',
+      () async {
     final runner = FakeRunner(resident: ['estate']);
     final bridge = NomosBridge(runner);
     await bridge.ready;
 
     var asked = false;
-    final s = await bridge.acquireSession('estate', ifAbsentCredentials: () async {
+    final s =
+        await bridge.acquireSession('estate', ifAbsentCredentials: () async {
       asked = true;
       return const NomosSessionCredentials(cloud: 'https://never.invalid');
     });
-    expect(asked, isFalse, reason: 'a resident workspace never asks for credentials');
+    expect(asked, isFalse,
+        reason: 'a resident workspace never asks for credentials');
     expect(s.workspace, 'estate');
     expect(runner.connectCount, 1);
     expect(runner.connectArgs(0).containsKey('cloud'), isFalse,
@@ -104,7 +114,9 @@ void main() {
     await bridge.dispose();
   });
 
-  test('concurrent acquisition SINGLE-FLIGHTS: one open, one credentials call, the same session', () async {
+  test(
+      'concurrent acquisition SINGLE-FLIGHTS: one open, one credentials call, the same session',
+      () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
     await bridge.ready;
@@ -122,8 +134,10 @@ void main() {
       bridge.acquireSession('cloudy', ifAbsentCredentials: creds),
       bridge.acquireSession('cloudy', ifAbsentCredentials: creds),
     ]);
-    expect(credentialCalls, 1, reason: 'the credentials callback fires exactly once');
-    expect(runner.connectCount, 1, reason: 'ONE connect for three concurrent acquires');
+    expect(credentialCalls, 1,
+        reason: 'the credentials callback fires exactly once');
+    expect(runner.connectCount, 1,
+        reason: 'ONE connect for three concurrent acquires');
     expect(identical(results[0], results[1]), isTrue);
     expect(identical(results[1], results[2]), isTrue);
     final args = runner.connectArgs(0);
@@ -133,7 +147,8 @@ void main() {
     await bridge.dispose();
   });
 
-  test('genuinely absent + no credentials callback → a named StateError (never a silent cloudless mount)',
+  test(
+      'genuinely absent + no credentials callback → a named StateError (never a silent cloudless mount)',
       () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
@@ -143,7 +158,9 @@ void main() {
     await bridge.dispose();
   });
 
-  test('a NomosSession delegates acquireSession to the parent plane (one registry)', () async {
+  test(
+      'a NomosSession delegates acquireSession to the parent plane (one registry)',
+      () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
     await bridge.ready;
@@ -157,17 +174,76 @@ void main() {
     await bridge.dispose();
   });
 
+  test('a resident child inherits its opening session identity', () async {
+    final runner = FakeRunner(resident: ['child']);
+    final bridge = NomosBridge(runner);
+    await bridge.ready;
+    await bridge.connect(
+      workspace: 'home',
+      session: 'home',
+      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
+    );
+
+    final child = await bridge.session('home').acquireSession('child');
+
+    expect(child.principal, 'user:ada');
+    await bridge.dispose();
+  });
+
+  test(
+      'a generated application session privately refreshes cloud access for an absent referenced workspace',
+      () async {
+    final runner = FakeRunner();
+    final bridge = NomosBridge(runner);
+    await bridge.ready;
+    await bridge.connect(
+      cloud: 'https://cloud.example',
+      workspace: 'home',
+      session: 'home',
+      authToken: 'header.eyJzdWIiOiJhZGEifQ.signature',
+      authorSecret: 'device-secret',
+    );
+    var refreshes = 0;
+    bridge.session('home').nomosInternalRetainCloudAccess(
+          cloud: 'https://cloud.example',
+          signIn: () async {
+            refreshes += 1;
+            return 'fresh-token-$refreshes';
+          },
+        );
+
+    final target = await bridge.session('home').acquireSession('shared-home');
+    expect(target.workspace, 'shared-home');
+    expect(refreshes, 1);
+    expect(runner.connectArgs(1)['cloud'], 'https://cloud.example');
+    expect(runner.connectArgs(1)['authToken'], 'fresh-token-1');
+    expect(runner.connectArgs(1)['authorSecret'], 'device-secret');
+    expect(target.principal, 'user:ada');
+
+    // The retained posture follows the opened handle, so navigation can continue without a public lane.
+    final child = await target.acquireSession('shared-child');
+    expect(child.workspace, 'shared-child');
+    expect(refreshes, 2);
+    expect(runner.connectArgs(2)['authToken'], 'fresh-token-2');
+    await bridge.dispose();
+  });
+
   // ── SESSION-STATE DX cluster (co2): explicit lifecycle state + fail-at-bind + openable refs ──
 
-  test('listWorkspaces() reports explicit state: resident/parked before open, connected after', () async {
-    final runner = FakeRunner(resident: ['estate']); // realm returns mounted:false, parked:true
+  test(
+      'listWorkspaces() reports explicit state: resident/parked before open, connected after',
+      () async {
+    final runner = FakeRunner(
+        resident: ['estate']); // realm returns mounted:false, parked:true
     final bridge = NomosBridge(runner);
     await bridge.ready;
 
     // Before any connect: the plane-resident (parked) workspace surfaces with an explicit non-connected state.
     var list = await bridge.listWorkspaces();
     final before = list.firstWhere((w) => w['workspace'] == 'estate');
-    expect(before['state'], 'parked', reason: 'parked custody is not connected — the app must acquire it first');
+    expect(before['state'], 'parked',
+        reason:
+            'parked custody is not connected — the app must acquire it first');
 
     // After connecting it, the SAME workspace reports connected.
     await bridge.connect(workspace: 'estate', session: 'estate');
@@ -177,7 +253,9 @@ void main() {
     await bridge.dispose();
   });
 
-  test('NomosSession.isConnected + assertConnected: fail at BIND, not on first query', () async {
+  test(
+      'NomosSession.isConnected + assertConnected: fail at BIND, not on first query',
+      () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
     await bridge.ready;
@@ -194,25 +272,32 @@ void main() {
     await bridge.dispose();
   });
 
-  test('NomosRef.acquire(bridge) opens a born/resident ref directly → a live session', () async {
+  test(
+      'NomosRef.acquire(bridge) opens a born/resident ref directly → a live session',
+      () async {
     final runner = FakeRunner(resident: ['estate-42']);
     final bridge = NomosBridge(runner);
     await bridge.ready;
 
     // The shape a `.births()` outcome yields: outcome.bornRefs.single is a NomosRef on the born workspace.
-    final ref = NomosRef(workspace: 'estate-42', type: 'nomos.Workspace', id: 'estate-42');
-    final session = await ref.acquire(bridge); // no credentials — resident opens local-only
+    final ref = NmsInternalNomosRefs.create<Object?>(
+        workspace: 'estate-42', type: 'nomos.Workspace', id: 'estate-42');
+    final session =
+        await ref.acquire(bridge); // no credentials — resident opens local-only
     expect(session.workspace, 'estate-42');
     expect(session.isConnected, isTrue);
     expect(identical(session, bridge.session('estate-42')), isTrue);
     await bridge.dispose();
   });
 
-  test('NomosRef.acquire refuses a workspace-less ref (a bad locator fails HERE, not later)', () async {
+  test(
+      'NomosRef.acquire refuses a workspace-less ref (a bad locator fails HERE, not later)',
+      () async {
     final runner = FakeRunner();
     final bridge = NomosBridge(runner);
     await bridge.ready;
-    final bad = NomosRef(workspace: '', type: 'nomos.Workspace', id: 'x');
+    final bad = NmsInternalNomosRefs.create<Object?>(
+        workspace: '', type: 'nomos.Workspace', id: 'x');
     expect(() => bad.acquire(bridge), throwsArgumentError);
     await bridge.dispose();
   });