@githolon/dsl 0.65.0 → 0.65.1

package/dart/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.43.0
+
+- `NomosBridge.foreignReader({cloud})` — a `NomosForeignReader` backed by the device's multi-workspace bridge
+  plane, so a generated `ForeignRef` (`t.foreignRef`) resolves against real data: it mounts the foreign
+  workspace on demand (`connect(session: ws, allowUnborn: true)`, idempotent) and reads it
+  (`session(ws).queryById(id)`); `watch` re-reads on each sync tick. A locator resolver, not a foreign key —
+  the foreign holon is mounted only when you resolve. Requires `nomos_types >= 0.1.1` (the `ForeignRef` types).
+
 ## 0.41.0
 - `NomosTestHarness` emits named phase-progress diagnostics (install → spawn runner → await ready → connect, plus per-session progress in `cluster`) and each `connect()` carries a `connectTimeout` (default 120s) that throws a NAMED remedy instead of hanging — so a multi-test AppSim run can tell install vs runner-wait vs session-block vs deadlock (co2 feedback).
 

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.41.0
+version: 0.43.0
 
 environment:
   sdk: ^3.5.0
@@ -20,7 +20,7 @@ dependencies:
   # The pure-data core (wire types, offer codec, NomosReads, schema validation, error
   # info). nomos_client depends on and re-exports it, so existing imports are unchanged.
   # For local monorepo dev, pubspec_overrides.yaml points this at ../dart_types.
-  nomos_types: ^0.1.0
+  nomos_types: ^0.1.1
   json_schema: ^5.2.2
   crypto: ^3.0.0
 

package/dart_types/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.1.1
+
+- Add `t.foreignRef` runtime types: `ForeignRef<T>` (a typed cross-workspace locator), `NomosForeignReader` /
+  `NomosForeignWorkspaceReader`, the sealed `ForeignResolveResult<T>` (`ForeignFound`/`ForeignNotFound`/
+  `ForeignDenied`/`ForeignUnreachable`), and `ForeignAttestation`. Generated read models type a `foreignRef`
+  field as `ForeignRef<Target>`; `.resolve/.resolveResult/.watch/.exists` are the informational lookup,
+  `.attest` is gated on the attested-read lane. Purely additive.
+
 ## 0.1.0
 - Initial release. The pure-data core split out of `nomos_client`: kernel wire types,
   the offer codec, `NomosReads`, the tri-state `NomosSlot`, aggregate metadata, schema

package/dart_types/pubspec.yaml

@@ -11,7 +11,7 @@ description: >-
   Pure kernel wire/data types for Nomos Dart frontends — no transport, no bridge,
   no runtime. The hand-written serde-JSON-compatible types plus the offer codec,
   reactive read engine, schema validation, and data-only error/trace types.
-version: 0.1.0
+version: 0.1.1
 
 environment:
   sdk: ^3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.65.0",
+  "version": "0.65.1",
   "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",

package/src/compile_package_main.ts

@@ -674,6 +674,15 @@ function emitDart(
     writeGenerated(FRAMEWORK_FILE, generateDartDomain(shared.frameworkMod));
   }
 
+  // CROSS-DOMAIN `t.foreignRef` (auto import). A foreignRef field typed `ForeignRef<CatalogueListing>` +
+  // `CatalogueListing.fromJson` needs the TARGET aggregate's Dart class — which lives in the target DOMAIN's
+  // generated file. Within ONE package the compiler knows which domain owns each aggregate, so we auto-emit
+  // the import (no manual `dartImports` config). Map every aggregate id → its domain's generated file base.
+  const aggIdToDartFile = new Map<string, string>();
+  for (const m of modules) {
+    for (const agg of (m.aggregates as { id: string }[])) aggIdToDartFile.set(agg.id, m.name);
+  }
+
   // 2b. one generated file per composed domain — the TYPES (`<name>.dart`) + the async bridge
   //     CLIENT (`<name>.client.dart`, the Flutter sibling of `<name>.client.ts`).
   for (const mod of modules) {
@@ -684,7 +693,28 @@ function emitDart(
     // framework import. Only pass the import when this domain actually folds a framework symbol.
     const { modForDart, skips, foldsFramework } = domainDedupOpts(mod, shared);
     const domainFrameworkImport = foldsFramework ? frameworkImportUri : undefined;
-    const src = generateDartDomain(modForDart, {
+    // AUTO cross-domain foreignRef imports: for each foreignRef whose target aggregate lives in ANOTHER
+    // tenant domain, import that domain's generated file so `ForeignRef<Target>` + `Target.fromJson` resolve.
+    // A target that is framework-shared resolves via the frameworkImportUri (not in the tenant map), so it is
+    // skipped here. Merged with any manual `dartImports`; deduped by uri.
+    const foreignRefImportUris = new Set<string>();
+    for (const agg of (modForDart.aggregates as { fields: Record<string, { foreignRef?: { targetAggregateId: string } }> }[])) {
+      for (const f of Object.values(agg.fields)) {
+        const tid = f.foreignRef?.targetAggregateId;
+        if (tid === undefined) continue;
+        const targetFile = aggIdToDartFile.get(tid);
+        if (targetFile !== undefined && targetFile !== modForDart.name) foreignRefImportUris.add(`${targetFile}.dart`);
+      }
+    }
+    const mergedDartImports = [
+      ...(modForDart.dartImports ?? []),
+      ...[...foreignRefImportUris]
+        .filter((uri) => !(modForDart.dartImports ?? []).some((i) => i.uri === uri))
+        .sort()
+        .map((uri) => ({ uri })),
+    ];
+    const modForDartWithImports = mergedDartImports.length > 0 ? { ...modForDart, dartImports: mergedDartImports } : modForDart;
+    const src = generateDartDomain(modForDartWithImports, {
       ...skips,
       ...(domainFrameworkImport !== undefined ? { frameworkImportUri: domainFrameworkImport } : {}),
     });
@@ -857,18 +887,29 @@ function emitDartPackages(
   // ── the TYPES package — pure data, `nomos_types` only ──
   const typesGen = freshGenDir(packages.types);
   const typesSources = new Map<string, string>(); // fileBase → src (for alias validation + purity)
+  // The SIBLING generated type files a types-package file MAY import (a cross-domain `t.foreignRef` types its
+  // field as the target aggregate's class, which lives in the target domain's file). A sibling types file is
+  // still PURE (no runtime/bridge surface — the purity gate exists to keep nomos_client out, not to isolate
+  // domain files from each other; Dart allows type-import cycles for mutual refs).
+  const siblingTypeFiles = new Set<string>([...modules.map((m) => `${m.name}.dart`), `${FRAMEWORK_FILE}.dart`]);
   const writeTypes = (fileBase: string, src: string): void => {
     if (!src.includes(DART_PACKAGE_IMPORT)) {
       fail(`generated Dart for '${fileBase}' does not carry the expected support import — codegen_dart header drifted`);
     }
     const pure = src.replace(DART_PACKAGE_IMPORT, DART_TYPES_IMPORT);
-    // PURITY, fail-closed: only the nomos_types barrel + the relative framework file may be imported.
+    // PURITY, fail-closed: only the nomos_types barrel, the framework file, and SIBLING generated type files
+    // (cross-domain foreignRef targets) may be imported. Runtime/bridge surfaces (nomos_client) stay out.
     for (const line of pure.split("\n")) {
       const m = /^import\s+'([^']+)'/.exec(line.trim());
-      if (m !== null && m[1] !== "package:nomos_types/nomos_types.dart" && m[1] !== `${FRAMEWORK_FILE}.dart`) {
+      if (
+        m !== null &&
+        m[1] !== "package:nomos_types/nomos_types.dart" &&
+        m[1] !== `${FRAMEWORK_FILE}.dart` &&
+        !siblingTypeFiles.has(m[1]!)
+      ) {
         fail(
           `types-package purity: generated '${fileBase}.dart' imports '${m[1]}' — a types file may only ` +
-            `import the nomos_types core (runtime/bridge surfaces belong in the client package)`,
+            `import the nomos_types core, the framework file, or a sibling generated domain file`,
         );
       }
     }
@@ -879,11 +920,28 @@ function emitDartPackages(
   };
 
   if (shared.frameworkMod !== undefined) writeTypes(FRAMEWORK_FILE, generateDartDomain(shared.frameworkMod));
+  // CROSS-DOMAIN foreignRef (layered): map aggregate id → its domain's type file, so a foreignRef field's
+  // target class resolves via a sibling import (the purity gate now permits sibling type files).
+  const aggIdToTypeFile = new Map<string, string>();
+  for (const m of modules) for (const agg of (m.aggregates as { id: string }[])) aggIdToTypeFile.set(agg.id, m.name);
   const perDomain = modules.map((mod) => ({ mod, dd: domainDedupOpts(mod, shared) }));
   for (const { mod, dd } of perDomain) {
+    const frImports = new Set<string>();
+    for (const agg of (dd.modForDart.aggregates as { fields: Record<string, { foreignRef?: { targetAggregateId: string } }> }[])) {
+      for (const f of Object.values(agg.fields)) {
+        const tid = f.foreignRef?.targetAggregateId;
+        const tf = tid !== undefined ? aggIdToTypeFile.get(tid) : undefined;
+        if (tf !== undefined && tf !== dd.modForDart.name) frImports.add(`${tf}.dart`);
+      }
+    }
+    const merged = [
+      ...(dd.modForDart.dartImports ?? []),
+      ...[...frImports].filter((uri) => !(dd.modForDart.dartImports ?? []).some((i) => i.uri === uri)).sort().map((uri) => ({ uri })),
+    ];
+    const modForTypes = merged.length > 0 ? { ...dd.modForDart, dartImports: merged } : dd.modForDart;
     writeTypes(
       mod.name,
-      generateDartDomain(dd.modForDart, {
+      generateDartDomain(modForTypes, {
         ...dd.skips,
         ...(dd.foldsFramework ? { frameworkImportUri: `${FRAMEWORK_FILE}.dart` } : {}),
       }),