@githolon/dsl 0.107.4 → 0.108.1

package/dart/lib/src/runtime_v2_gateway.dart

@@ -0,0 +1,54 @@
+@internal
+library;
+
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+import 'package:nomos_types/nomos_types.dart'
+    show NomosErrorInfo, nomosErrorFromInfo;
+
+import 'runtime_v2_transport.dart';
+
+/// Correlates generated Runtime v2 frames and translates only the generated
+/// failure arm. It knows nothing about sessions, domains, lifecycle policy, or
+/// application state; those remain with the caller that owns each command.
+final class NmsRuntimeV2Gateway {
+  NmsRuntimeV2Gateway(this._transport);
+
+  final NomosRuntimeV2Transport _transport;
+  int _sequence = 0;
+
+  Future<nomos_protocol.RuntimeResponse> invoke(
+    nomos_protocol.RuntimeRequest request,
+  ) async {
+    final requestId = fixnum.Int64(++_sequence);
+    request
+      ..protocolVersion = 2
+      ..requestId = requestId;
+    final response = await _transport.invokeRuntime(request);
+    if (response.protocolVersion != 2) {
+      throw StateError(
+        'Nomos host returned Runtime protocol ${response.protocolVersion}',
+      );
+    }
+    if (response.requestId != requestId) {
+      throw StateError(
+        'Runtime v2 response ${response.requestId} belongs to another request',
+      );
+    }
+    if (response.hasFailure()) {
+      final failure = response.failure;
+      throw nomosErrorFromInfo(
+        NomosErrorInfo(
+          code: failure.code,
+          message: failure.message,
+          component: failure.component,
+          workspace: failure.hasWorkspace() ? failure.workspace : null,
+          domain: failure.hasDomain() ? failure.domain : null,
+          directiveId: failure.hasDirective() ? failure.directive : null,
+        ),
+      );
+    }
+    return response;
+  }
+}

package/dart/lib/src/runtime_v2_transport.dart

@@ -0,0 +1,117 @@
+@internal
+library;
+
+import 'dart:async';
+
+import 'package:fixnum/fixnum.dart' as fixnum;
+import 'package:meta/meta.dart' show internal;
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
+/// Binary generated-message path from an application host to the kernel.
+abstract interface class NomosKernelCallTransport {
+  Future<nomos_protocol.CallResponse> callKernel({
+    required String session,
+    required nomos_protocol.CallRequest request,
+  });
+}
+
+/// Exact Runtime v2 frame exchange. Platform transports carry bytes; they do
+/// not acquire command names, argument bags, or domain result semantics.
+abstract interface class NomosRuntimeV2Transport {
+  Future<nomos_protocol.RuntimeResponse> invokeRuntime(
+    nomos_protocol.RuntimeRequest request,
+  );
+}
+
+/// Generated asynchronous runtime event lane. It is separate from invocation
+/// correlation because a watch/sync event has no request future to complete.
+abstract interface class NomosRuntimeV2EventTransport {
+  Stream<nomos_protocol.RuntimeEvent> get runtimeEvents;
+}
+
+/// A level-triggered generated event stream. Runtime readiness can arrive while
+/// a WebView script is loading, before [NomosBridge] exists; a broadcast stream
+/// would silently discard it and turn a successful boot into an infinite wait.
+/// Buffering ends when the first bridge subscribes, after which events remain a
+/// normal broadcast stream.
+final class NmsBufferedRuntimeEvents {
+  NmsBufferedRuntimeEvents() {
+    _controller = StreamController<nomos_protocol.RuntimeEvent>.broadcast(
+      onListen: _attach,
+    );
+  }
+
+  late final StreamController<nomos_protocol.RuntimeEvent> _controller;
+  final List<nomos_protocol.RuntimeEvent> _pending = [];
+  bool _attached = false;
+
+  Stream<nomos_protocol.RuntimeEvent> get stream => _controller.stream;
+  bool get isClosed => _controller.isClosed;
+
+  void _attach() {
+    if (_attached) return;
+    _attached = true;
+    final pending = List<nomos_protocol.RuntimeEvent>.of(_pending);
+    _pending.clear();
+    for (final event in pending) {
+      if (!_controller.isClosed) _controller.add(event);
+    }
+  }
+
+  void add(nomos_protocol.RuntimeEvent event) {
+    if (_controller.isClosed) return;
+    if (_attached) {
+      _controller.add(event);
+    } else {
+      _pending.add(event);
+    }
+  }
+
+  void addError(Object error, [StackTrace? stackTrace]) {
+    if (_controller.isClosed) return;
+    _controller.addError(error, stackTrace);
+  }
+
+  Future<void> close() {
+    _pending.clear();
+    return _controller.close();
+  }
+}
+
+/// Shared typed kernel-call lowering for every Runtime v2 transport.
+mixin NomosRuntimeV2KernelCalls
+    implements NomosRuntimeV2Transport, NomosKernelCallTransport {
+  int _nmsRuntimeRequestSequence = 0;
+
+  @override
+  Future<nomos_protocol.CallResponse> callKernel({
+    required String session,
+    required nomos_protocol.CallRequest request,
+  }) async {
+    final requestId = fixnum.Int64(++_nmsRuntimeRequestSequence);
+    final response = await invokeRuntime(
+      nomos_protocol.RuntimeRequest(
+        protocolVersion: 2,
+        requestId: requestId,
+        kernelCall: nomos_protocol.KernelCallRequest(
+          session: session,
+          request: request,
+        ),
+      ),
+    );
+    if (response.requestId != requestId) {
+      throw StateError(
+        'Runtime v2 response ${response.requestId} belongs to another request',
+      );
+    }
+    if (response.hasFailure()) {
+      throw StateError('${response.failure.code}: ${response.failure.message}');
+    }
+    if (!response.hasKernelCall()) {
+      throw StateError(
+        'Runtime v2 returned ${response.whichOutcome().name} for a kernel call',
+      );
+    }
+    return response.kernelCall;
+  }
+}

package/dart/lib/src/session_bound.dart

@@ -28,6 +28,8 @@ import 'package:meta/meta.dart' show internal;
 
 import 'dart:convert';
 
+import 'package:nomos_types/nomos_kernel_protocol.dart' as nomos_protocol;
+
 import 'webview_bridge.dart';
 
 /// The STATIC INTERFACE DESCRIPTOR a generated client exposes as `XClient.interface` — what the
@@ -474,8 +476,11 @@ extension NomosSessionCompat on NomosSession {
         final m = await metrics();
         behind = ((m['behind'] as num?) ?? 0).toInt();
         final listed = await listWorkspaces();
-        cloudBound = listed.any((w) =>
-            w['workspace'] == workspace && w['syncPosture'] == 'cloud-bound');
+        cloudBound = listed.any((candidate) =>
+            candidate.workspace == workspace &&
+            candidate.syncPosture ==
+                nomos_protocol
+                    .WorkspaceSyncPosture.WORKSPACE_SYNC_POSTURE_CLOUD_BOUND);
       } catch (_) {/* best-effort */}
       if (cloudBound && behind > 0) {
         cause = SessionMismatchCause.liveCloudHasLawButLocalStale;