@githolon/dsl 0.13.0 → 0.15.0

package/dart/test/webview_bridge_test.dart

@@ -19,7 +19,8 @@ class FakeRunner implements BridgeTransport {
 
   FakeRunner() {
     // the runner announces readiness at construction.
-    scheduleMicrotask(() => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'ready'}));
+    scheduleMicrotask(
+        () => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'ready'}));
   }
 
   @override
@@ -32,34 +33,97 @@ class FakeRunner implements BridgeTransport {
     final op = message['op'] as String;
     final args = (message['args'] as Map).cast<String, Object?>();
     // reply exactly as the runner's ops do (the contract both ends share).
-    Map<String, Object?> reply(Object? result) => {'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result};
+    Map<String, Object?> reply(Object? result) =>
+        {'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result};
     scheduleMicrotask(() {
       switch (op) {
-        case 'connect': _incoming.add(reply({'workspace': args['workspace']})); break;
-        case 'dispatch':
+        case 'connect':
+          _incoming.add(reply({'workspace': args['workspace']}));
+          break;
+        case 'offer':
           // a directive the law refuses answers ok:false (the runner frames the gate's verdict).
-          if (args['directiveId'] == 'refuseMe') {
-            _incoming.add({'v': kWebviewBridgeVersion, 'id': id, 'ok': false, 'error': 'the law refused this intent'});
+          final intentJson =
+              utf8.decode(base64Decode(args['intentBytes'] as String));
+          if (intentJson.contains('"directiveId":"refuseMe"')) {
+            _incoming.add({
+              'v': kWebviewBridgeVersion,
+              'id': id,
+              'ok': false,
+              'error': 'the law refused this intent'
+            });
           } else {
-            _incoming.add(reply({'head': 'HEAD-${args['directiveId']}'}));
+            _incoming.add(reply({'head': 'HEAD-offer'}));
           }
           break;
-        case 'deliverShare': _incoming.add(reply({'head': 'HEAD-share'})); break;
-        case 'query': _incoming.add(reply({'rows': [{'id': 'a', 'data': {'q': args['queryId']}}]})); break;
-        case 'queryById': _incoming.add(reply({'rows': [{'id': args['id'], 'data': {'ok': true}}]})); break;
-        case 'count': _incoming.add(reply({'count': 7})); break;
-        case 'sync': _incoming.add(reply({'pushed': true})); break;
-        case 'lawStatus': _incoming.add(reply({'installed': true, 'drifted': false})); break;
-        case 'badop': _incoming.add({'v': kWebviewBridgeVersion, 'id': id, 'ok': false, 'error': 'the law refused this intent'}); break;
-        case 'watch': lastWatchSubId = args['subId'] as String; _incoming.add(reply({'subId': args['subId']})); break;
-        case 'unwatch': _incoming.add(reply({'subId': args['subId']})); break;
-        default: _incoming.add({'v': kWebviewBridgeVersion, 'id': id, 'ok': false, 'error': "unknown op '$op'"});
+        case 'query':
+          _incoming.add(reply({
+            'rows': [
+              {
+                'id': 'a',
+                'data': {'q': args['queryId']}
+              }
+            ]
+          }));
+          break;
+        case 'queryById':
+          _incoming.add(reply({
+            'rows': [
+              {
+                'id': args['id'],
+                'data': {'ok': true}
+              }
+            ]
+          }));
+          break;
+        case 'count':
+          _incoming.add(reply({'count': 7}));
+          break;
+        case 'sync':
+          _incoming.add(reply({'pushed': true}));
+          break;
+        case 'autoSync':
+          _incoming.add(reply({'started': true}));
+          break;
+        case 'lawStatus':
+          _incoming.add(reply({'installed': true, 'drifted': false}));
+          break;
+        case 'badop':
+          _incoming.add({
+            'v': kWebviewBridgeVersion,
+            'id': id,
+            'ok': false,
+            'error': 'the law refused this intent'
+          });
+          break;
+        case 'watch':
+          lastWatchSubId = args['subId'] as String;
+          _incoming.add(reply({'subId': args['subId']}));
+          break;
+        case 'unwatch':
+          _incoming.add(reply({'subId': args['subId']}));
+          break;
+        default:
+          _incoming.add({
+            'v': kWebviewBridgeVersion,
+            'id': id,
+            'ok': false,
+            'error': "unknown op '$op'"
+          });
       }
     });
   }
 
   /// Simulate the holon firing a reactive change to an active watch.
-  void pushWatch(String subId, List<dynamic> rows) => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'watch', 'subId': subId, 'rows': rows});
+  void pushWatch(String subId, List<dynamic> rows) => _incoming.add({
+        'v': kWebviewBridgeVersion,
+        'event': 'watch',
+        'subId': subId,
+        'rows': rows
+      });
+
+  /// Simulate the runner forwarding a signal holon projection.
+  void pushSignal(Map<String, Object?> signal) => _incoming
+      .add({'v': kWebviewBridgeVersion, 'event': 'signal', 'signal': signal});
 }
 
 /// A transport that answers EVERY request with one canned `result` (the golden corpus's reply) and records
@@ -69,7 +133,8 @@ class ReplayTransport implements BridgeTransport {
   final _incoming = StreamController<Map<String, Object?>>.broadcast();
   Map<String, Object?>? lastRequest;
   ReplayTransport(this.result) {
-    scheduleMicrotask(() => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'ready'}));
+    scheduleMicrotask(
+        () => _incoming.add({'v': kWebviewBridgeVersion, 'event': 'ready'}));
   }
   @override
   Stream<Map<String, Object?>> get messages => _incoming.stream;
@@ -77,7 +142,8 @@ class ReplayTransport implements BridgeTransport {
   void send(Map<String, Object?> message) {
     lastRequest = message;
     final id = message['id'];
-    scheduleMicrotask(() => _incoming.add({'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result}));
+    scheduleMicrotask(() => _incoming.add(
+        {'v': kWebviewBridgeVersion, 'id': id, 'ok': true, 'result': result}));
   }
 }
 
@@ -91,24 +157,29 @@ Map<String, Object?> _loadCorpus() {
   ];
   for (final p in candidates) {
     final f = File(p);
-    if (f.existsSync()) return (jsonDecode(f.readAsStringSync()) as Map).cast<String, Object?>();
+    if (f.existsSync())
+      return (jsonDecode(f.readAsStringSync()) as Map).cast<String, Object?>();
   }
-  fail('golden corpus not found from ${Directory.current.path}; tried $candidates');
+  fail(
+      'golden corpus not found from ${Directory.current.path}; tried $candidates');
 }
 
 /// Drive one corpus op through the typed bridge method and return its typed result (so we can compare it to
 /// what the corpus says the unwrapped value should be).
-Future<Object?> _invoke(NomosBridge b, String op, Map<String, Object?> a) async {
+Future<Object?> _invoke(
+    NomosBridge b, String op, Map<String, Object?> a) async {
   switch (op) {
     case 'connect':
-      await b.connect(cloud: a['cloud'] as String, workspace: a['workspace'] as String, clientId: a['clientId'] as String?);
+      await b.connect(
+          cloud: a['cloud'] as String,
+          workspace: a['workspace'] as String,
+          clientId: a['clientId'] as String?);
       return null;
-    case 'dispatch':
-      return b.dispatch(domain: a['domain'] as String, directiveId: a['directiveId'] as String, payload: (a['payload'] as Map).cast<String, Object?>(), domainHash: a['domainHash'] as String);
-    case 'deliverShare':
-      return b.deliverShare(quote: (a['quote'] as Map).cast<String, Object?>(), domainHash: a['domainHash'] as String);
+    case 'offer':
+      return b.offer(intentBytes: a['intentBytes'] as String);
     case 'query':
-      return b.query(a['queryId'] as String, (a['params'] as Map).cast<String, Object?>());
+      return b.query(
+          a['queryId'] as String, (a['params'] as Map).cast<String, Object?>());
     case 'queryById':
       return b.queryById(a['id'] as String);
     case 'count':
@@ -127,8 +198,9 @@ Future<Object?> _invoke(NomosBridge b, String op, Map<String, Object?> a) async
 /// What the corpus says the typed (unwrapped) return value should be, given the reply's `result`.
 Object? _expectedTyped(String op, Map<String, Object?> result) {
   switch (op) {
-    case 'dispatch':
-    case 'deliverShare':
+    case 'offer':
+      return result['head'];
+    case 'offer':
       return result['head'];
     case 'query':
     case 'queryById':
@@ -153,7 +225,8 @@ void main() {
   group('golden corpus (shared with the JS runner)', () {
     final corpus = _loadCorpus();
     final cases = (corpus['cases'] as List).cast<Map<String, Object?>>();
-    test('version pins the bridge version', () => expect(corpus['version'], kWebviewBridgeVersion));
+    test('version pins the bridge version',
+        () => expect(corpus['version'], kWebviewBridgeVersion));
     for (final c in cases) {
       final op = c['op'] as String;
       final args = (c['args'] as Map).cast<String, Object?>();
@@ -163,8 +236,12 @@ void main() {
         final bridge = NomosBridge(transport);
         await bridge.ready;
         final typed = await _invoke(bridge, op, args);
-        expect((transport.lastRequest!['args'] as Map).cast<String, Object?>(), equals(args), reason: 'sent request args');
-        if (op != 'connect') expect(typed, equals(_expectedTyped(op, result)), reason: 'parsed typed result');
+        expect((transport.lastRequest!['args'] as Map).cast<String, Object?>(),
+            equals(args),
+            reason: 'sent request args');
+        if (op != 'connect')
+          expect(typed, equals(_expectedTyped(op, result)),
+              reason: 'parsed typed result');
         await bridge.dispose();
       });
     }
@@ -172,50 +249,116 @@ void main() {
 
   late FakeRunner runner;
   late NomosBridge bridge;
-  setUp(() { runner = FakeRunner(); bridge = NomosBridge(runner); });
+  setUp(() {
+    runner = FakeRunner();
+    bridge = NomosBridge(runner);
+  });
   tearDown(() => bridge.dispose());
 
   test('ready completes once the runner boots', () async {
     await bridge.ready.timeout(const Duration(seconds: 1));
   });
 
-  test('dispatch round-trips a typed head; args reach the runner verbatim', () async {
+  test('offer round-trips a typed head; args reach the runner verbatim',
+      () async {
     await bridge.ready;
-    final head = await bridge.dispatch(domain: 'guestbook', directiveId: 'signGuestbook', payload: {'author': 'ada'}, domainHash: 'abc');
-    expect(head, 'HEAD-signGuestbook');
-    final req = runner.sent.firstWhere((m) => m['op'] == 'dispatch');
-    expect((req['args'] as Map)['payload'], {'author': 'ada'});
-    expect((req['args'] as Map)['domainHash'], 'abc');
+    final intentBytes = base64Encode(utf8.encode(jsonEncode({
+      'v': 2,
+      'intent': {
+        'domain': 'guestbook',
+        'directiveId': 'signGuestbook',
+        'payload': {'author': 'ada'},
+        'domainHash': 'abc'
+      }
+    })));
+    final head = await bridge.offer(intentBytes: intentBytes);
+    expect(head, 'HEAD-offer');
+    final req = runner.sent.firstWhere((m) => m['op'] == 'offer');
+    expect((req['args'] as Map)['intentBytes'], intentBytes);
   });
 
-  test('connect / deliverShare / query / queryById / count / sync / lawStatus all wrap the runner', () async {
+  test(
+      'connect / query / queryById / count / sync / lawStatus all wrap the runner',
+      () async {
     await bridge.ready;
     await bridge.connect(cloud: 'https://c', workspace: 'ws', clientId: 'c1');
-    expect(await bridge.deliverShare(quote: {'publicKey': 'k'}, domainHash: 'h'), 'HEAD-share');
-    expect((await bridge.query('byAuthor', {'author': 'ada'})).first['data'], {'q': 'byAuthor'});
+    expect((await bridge.query('byAuthor', {'author': 'ada'})).first['data'],
+        {'q': 'byAuthor'});
     expect((await bridge.queryById('Entry_1')).first['id'], 'Entry_1');
     expect(await bridge.count('entries'), 7);
     expect(await bridge.sync(), {'pushed': true});
-    expect(await bridge.lawStatus('abc'), {'installed': true, 'drifted': false});
+    expect(
+        await bridge.lawStatus('abc'), {'installed': true, 'drifted': false});
   });
 
-  test('watch is a reactive stream; a runner push reaches the listener; cancel unwatches', () async {
+  test(
+      'watch is a reactive stream; a runner push reaches the listener; cancel unwatches',
+      () async {
     await bridge.ready;
     final got = <List<dynamic>>[];
     final sub = bridge.watch('byAuthor', {'author': 'ada'}).listen(got.add);
     await Future<void>.delayed(Duration.zero); // let the watch register
-    runner.pushWatch(runner.lastWatchSubId!, [{'id': 'a', 'data': {'n': 2}}]);
+    runner.pushWatch(runner.lastWatchSubId!, [
+      {
+        'id': 'a',
+        'data': {'n': 2}
+      }
+    ]);
     await Future<void>.delayed(Duration.zero);
-    expect(got, [[{'id': 'a', 'data': {'n': 2}}]]);
+    expect(got, [
+      [
+        {
+          'id': 'a',
+          'data': {'n': 2}
+        }
+      ]
+    ]);
     await sub.cancel();
     expect(runner.sent.any((m) => m['op'] == 'unwatch'), isTrue);
   });
 
-  test('a law refusal throws NomosBridgeError with the verbatim message', () async {
+  test('signal events are forwarded on their own stream', () async {
+    await bridge.ready;
+    final got = <Map<String, Object?>>[];
+    final sub = bridge.signalEvents.listen(got.add);
+    runner.pushSignal({
+      'type': 'signal.projection',
+      'domain': 'presence',
+      'projection': {
+        'peers': [
+          {'clientId': 'prof-a', 'behindBest': 141},
+        ],
+      },
+    });
+    await Future<void>.delayed(Duration.zero);
+    expect(got.single['signal'], isA<Map>());
+    expect(((got.single['signal'] as Map)['projection'] as Map)['peers'],
+        isA<List>());
+    await sub.cancel();
+  });
+
+  test('autoSync forwards a scoped signal id', () async {
+    await bridge.ready;
+    await bridge.autoSync(signalId: 'signal:ws:list:main');
+    final req = runner.sent.firstWhere((m) => m['op'] == 'autoSync');
+    expect((req['args'] as Map)['signalId'], 'signal:ws:list:main');
+  });
+
+  test('a law refusal throws NomosBridgeError with the verbatim message',
+      () async {
     await bridge.ready;
     Object? err;
     try {
-      await bridge.dispatch(domain: 'x', directiveId: 'refuseMe', payload: {}, domainHash: 'h');
+      await bridge.offer(
+          intentBytes: base64Encode(utf8.encode(jsonEncode({
+        'v': 2,
+        'intent': {
+          'domain': 'x',
+          'directiveId': 'refuseMe',
+          'payload': {},
+          'domainHash': 'h'
+        }
+      }))));
     } on NomosBridgeError catch (e) {
       err = e;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.13.0",
+  "version": "0.15.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",
@@ -11,8 +11,8 @@
   },
   "main": "src/index.ts",
   "bin": {
-    "nomos-compile": "./compile_package.mjs",
-    "holon-compile": "./compile_package.mjs"
+    "nomos-compile": "compile_package.mjs",
+    "holon-compile": "compile_package.mjs"
   },
   "exports": {
     ".": "./src/index.ts",
@@ -44,6 +44,8 @@
     "src",
     "!src/**/*.test.ts",
     "dart",
+    "!dart/.dart_tool",
+    "!dart/build",
     "compile_package.mjs"
   ],
   "publishConfig": {

package/src/build_package.ts

@@ -157,7 +157,7 @@ export function composeDomainModule(spec: DomainModuleSpec): DomainModule {
   const aggregates = [...byId.values()];
   const directiveIds = new Set(directives.map((d) => d.id));
   for (const task of spec.impureCapabilities ?? []) {
-    for (const directive of [task.order, task.complete, task.fail, task.block, task.deadLetter]) {
+    for (const directive of [task.obligation, task.complete, task.fail, task.block, task.deadLetter]) {
       if (!directiveIds.has(directive.id)) {
         throw new Error(
           `domain '${spec.domain ?? spec.name}' declares impureCapability '${task.aggregate.id}' ` +

package/src/capability_exports.ts

@@ -16,7 +16,7 @@
  * properties — invisible to those walks. This helper, applied at each plane's
  * merge point (the engine lump's `mergeModules`, the package composer's merge,
  * the compile CLI's merge), ADDS the bundle's pieces to the exports bag under
- * synthetic names (`<export>$aggregate`, `<export>$order`, …) so every
+ * synthetic names (`<export>$aggregate`, `<export>$obligation`, …) so every
  * existing shape-walk discovers them with ZERO new walk semantics. The
  * original bundle export stays (config-named lanes still resolve it); the
  * walks ignore its unmatched shape exactly as before.
@@ -34,7 +34,7 @@ export function isCapabilityDecl(v: unknown): v is Record<string, unknown> {
   );
 }
 
-const PIECES = ["aggregate", "order", "complete", "fail", "block", "deadLetter", "tasks"] as const;
+const PIECES = ["aggregate", "obligation", "complete", "fail", "block", "deadLetter", "tasks"] as const;
 
 /**
  * Expand every `capability()` bundle in an exports bag into discoverable

package/src/codegen_dart.ts

@@ -15,13 +15,13 @@
  *     emit (e.g. `{name:"HQ", createdAt:1000}`);
  *   - typed READ accessors per aggregate + per declared query — reactive
  *     `watch…`/one-shot `read…` over the GitHolon `query()`/`query_by_id()`
- *     surface (the read half of the dispatch(intent) boundary);
+ *     surface (the read half of the offer/query boundary);
  *   - a Dart enum per `t.enum([...])` field;
  *   - a Dart intent class per domain action — a pure typed DTO. Each class exposes its
  *     `domain` / `intentType` (so the call site never hand-types a string) and a
  *     `toPayloadJson()` that serialises only its typed fields to data. It builds no
  *     `Event` and no `Hlc`: the GitHolon executes the installed domain plan.
- *   - a single generic write verb [`dispatch`] that ships {domain, intentType,
+ *   - a single generic effectful write verb [`offer`] that ships {domain, intentType,
  *     toPayloadJson()} to the GitHolon `author(domain, intentType, payloadJson, actor)`.
  *
  * It does NOT hand-write the fixed wire types (`Value`/`Op`/`Event`/...): those
@@ -828,7 +828,7 @@ function emitPermissionVocabulary(vocab: PermissionVocabulary | undefined): stri
   return [
     `/// Generated permission vocabulary from the domain role catalogue.`,
     `///`,
-    `/// This is frontend read/dispatch vocabulary only. Domain execution and`,
+    `/// This is frontend read/offer vocabulary only. Domain execution and`,
     `/// admission still happen inside the installed GitHolon domain law.`,
     `class PermissionRole {`,
     `  const PermissionRole(this.value, this.capabilities);`,
@@ -1125,7 +1125,7 @@ function emitEvidenceRefClass(): string {
     `    );`,
     `  }`,
     ``,
-    `  /// The authored payload shape (for dispatch): the typed value-object the DSL`,
+    `  /// The authored payload shape (for offer): the typed value-object the DSL`,
     `  /// \`t.evidence()\` field lowers to a kernel \`Value::Evidence\`.`,
     `  Map<String, Object?> toJson() => <String, Object?>{`,
     `        'hash': hash,`,
@@ -1536,7 +1536,7 @@ function emitDirective(
     `/// Generated typed intent DTO for '${d.id}' (marker: ${d.marker},`,
     `/// aggregate: ${d.aggregateId}). It carries its [domain] + [intentType] and a`,
     `/// [toPayloadJson] that ships only typed fields as data. It builds no`,
-    `/// \`Event\` and no \`Hlc\`. Pass it to [dispatch]; the GitHolon executes`,
+    `/// \`Event\` and no \`Hlc\`. Pass it to [offer]; the GitHolon executes`,
     `/// the installed domain plan.`,
     `class ${className} implements NomosIntent {`,
     `  /// The policy domain this intent belongs to (the kernel \`author\` \`domain\`).`,
@@ -1587,7 +1587,7 @@ export function toJsonExpr(spec: PayloadFieldSpec, accessor: string): string {
 
 // ---- read accessors (typed subscriptions) ----------------------------------
 //
-// The READ half of the peer dispatch surface (Jack 2026-06-01): the app reads ONLY via
+// The READ half of the peer query surface (Jack 2026-06-18): the app reads ONLY via
 // these generated typed accessors over the GitHolon read surface
 // (`query(query_id, params_json)` + `query_by_id(aggregate_id)`, #140's indexed/PK
 // read-closure). It invents NO new Rust read primitive. Two emitters:
@@ -2503,11 +2503,11 @@ export interface DomainModule {
    */
   readModelAggregates?: string[];
   /**
-   * The domain's `impureCapability` capabilities (framework Order→Receipt; `impure_capability.ts`)
+   * The domain's `impureCapability` capabilities (framework Obligation→Receipt; `impure_capability.ts`)
    * for which to ALSO emit the typed PROVIDER SDK — the symmetric twin of the peer
-   * payload classes. For each declared task the codegen emits a typed `XOrder` (+
+   * payload classes. For each declared task the codegen emits a typed `XObligation` (+
    * `fromJson`), `XResult`/`XFailure`, a `XHandler` typedef and a `XProvider` dispatcher
-   * that decodes the incoming Order JSON and encodes the Receipt (reusing the
+   * that decodes the incoming Obligation JSON and encodes the Receipt (reusing the
    * peer-codegen `CompleteXPayload`/`FailXPayload`, so the Receipt is an ordinary
    * intent through the ONE write path). ADDITIVE + OPTIONAL: a domain that omits this is
    * byte-identical to before. NOT carried into any manifest/hash — a pure provider-side
@@ -2571,10 +2571,10 @@ export function generateDartDomain(mod: DomainModule): string {
   const mintedBlock = emitMintedCreates(mod.aggregates, mod.directives, domainKey, dartTypes);
 
   // PROVIDER SDK (the symmetric twin of the peer payload classes): for each declared
-  // `impureCapability` capability, a typed Order/Result/Failure + handler typedef + dispatcher.
+  // `impureCapability` capability, a typed Obligation/Result/Failure + handler typedef + dispatcher.
   // ADDITIVE + omit-when-empty: a domain with no `impureCapabilities` emits nothing (and the
   // `provider.dart` import is omitted), so it is byte-identical to before. The enum map is
-  // SHARED with the directive/aggregate codegen so an enum-typed order param references the
+  // SHARED with the directive/aggregate codegen so an enum-typed obligation param references the
   // already-emitted domain enum (no duplicate decl).
   const providerBlock = emitProviderSdk(mod.impureCapabilities ?? [], dartTypes);
 
@@ -2766,7 +2766,7 @@ export function generateDartDomain(mod: DomainModule): string {
           ``,
         ]
       : []),
-    `// ---- public intents (typed DTOs; ship via the generic dispatch() verb) ----`,
+    `// ---- public intents (typed DTOs; ship via the generic offer() verb) ----`,
     dirBlock,
     ``,
     ...(mintedBlock !== ""

package/src/codegen_dart_client.ts

@@ -13,7 +13,7 @@
  * hashed (the deployed law's content hash baked in), carrying a `<Domain>Client` over a connected
  * [NomosBridge] (the WebView runner) with:
  *
- *   * a typed DISPATCH method per directive — takes the generated `…Payload`, serialises via its
+ *   * a typed OFFER method per directive — takes the generated `…Payload`, serialises via its
  *     `toPayloadJson()`, auto-stamps omitted `…At` timestamps (the same caller-clock sugar the TS
  *     client applies), returns the new local head;
  *   * a typed declared-QUERY accessor per `query(...)` — one-shot `Future<List<…ReadModel>>` + a
@@ -81,7 +81,7 @@ function rowToModel(model: string, rowVar: string): string {
 }
 
 export interface DartBridgeClientOptions {
-  /** sha256 of the built `.package.usda` — the law this client dispatches under. */
+  /** sha256 of the built `.package.usda` — the law this client offers under. */
   readonly domainHash: string;
 }
 
@@ -95,7 +95,7 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
 
   const methods: string[] = [];
 
-  // ── directives → typed dispatch ──
+  // ── directives → typed offer ──
   const dirs = (mod.directives as AnyDirective[]).filter(
     (d) => d && typeof d.id === "string" && typeof (d as { payloadSchema?: unknown }).payloadSchema === "object",
   );
@@ -106,12 +106,12 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
     if (stamps.length > 0) {
       methods.push(
         `  /// Author \`${domain}/${d.id}\` locally under the installed law; returns the new local head.`,
-        `  /// Omitted ${stamps.map((s) => `\`${s}\``).join(" / ")} auto-stamp(s) ISO now() at dispatch.`,
+        `  /// Omitted ${stamps.map((s) => `\`${s}\``).join(" / ")} auto-stamp(s) ISO now() at offer.`,
         `  Future<String> ${method}(${payloadClass} payload) {`,
         `    final data = payload.toPayloadJson();`,
         `    final now = DateTime.now().toUtc().toIso8601String();`,
         ...stamps.map((s) => `    data.putIfAbsent(${dartStr(s)}, () => now);`),
-        `    return bridge.dispatch(domain: ${dartStr(domain)}, directiveId: ${dartStr(d.id)}, payload: data, domainHash: domainHash);`,
+        `    return bridge.offer(intentBytes: _encodeIntentOffer(${dartStr(domain)}, ${dartStr(d.id)}, data, domainHash));`,
         `  }`,
         ``,
       );
@@ -119,7 +119,7 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
       methods.push(
         `  /// Author \`${domain}/${d.id}\` locally under the installed law; returns the new local head.`,
         `  Future<String> ${method}(${payloadClass} payload) =>`,
-        `      bridge.dispatch(domain: ${dartStr(domain)}, directiveId: ${dartStr(d.id)}, payload: payload.toPayloadJson(), domainHash: domainHash);`,
+        `      bridge.offer(intentBytes: _encodeIntentOffer(${dartStr(domain)}, ${dartStr(d.id)}, payload.toPayloadJson(), domainHash));`,
         ``,
       );
     }
@@ -196,6 +196,8 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
     `//   final app = ${className}(bridge);`,
     `//   await app.${dirs[0] ? safeMethod(dirs[0].id) : "someDirective"}(/* typed payload */);`,
     ``,
+    `import 'dart:convert';`,
+    ``,
     `import 'nomos_dsl.dart';`,
     `import '${mod.name}.dart';`,
     `// Re-export the sibling types (read models + payloads + the bridge runtime) so ONE import of this`,
@@ -203,9 +205,20 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
     `export '${mod.name}.dart';`,
     `export 'nomos_dsl.dart' show NomosBridge, BridgeTransport, NomosBridgeError, kWebviewBridgeVersion;`,
     ``,
-    `/// sha256 of the deployed \`.package.usda\` — the installed law this client dispatches under.`,
+    `/// sha256 of the deployed \`.package.usda\` — the installed law this client offers under.`,
     `const String ${hashConst} = ${dartStr(opts.domainHash)};`,
     ``,
+    `String _encodeIntentOffer(String domain, String directiveId, Object? payload, String domainHash) =>`,
+    `    base64Encode(utf8.encode(jsonEncode({`,
+    `      'v': 2,`,
+    `      'intent': {`,
+    `        'domain': domain,`,
+    `        'directiveId': directiveId,`,
+    `        'payload': payload,`,
+    `        'domainHash': domainHash,`,
+    `      },`,
+    `    })));`,
+    ``,
     `/// Typed async client for the \`${domain}\` domain, bound to a connected [NomosBridge].`,
     `class ${className} {`,
     `  final NomosBridge bridge;`,