@githolon/dsl 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.5.0",
+  "version": "0.5.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/codegen_proof.ts

@@ -188,6 +188,77 @@ export interface TsProofOptions {
   readonly domainHash: string;
 }
 
+/** The machine-readable OFFLINE legs for ONE domain (the `@nomos-proof-legs`
+ *  marker shape; the `proof-legs.json` index is a map of these by domain key). */
+export interface ProofLegs {
+  readonly domain: string;
+  readonly directiveId: string;
+  readonly aggregateId: string;
+  readonly payload: Record<string, unknown>;
+  readonly autoStamped: readonly string[];
+  readonly mintField?: string;
+  readonly query?: { readonly id: string; readonly params: Record<string, unknown> };
+  readonly count?: { readonly id: string; readonly group: string };
+}
+
+/** Synthesize the offline legs for one domain module, or `null` when it has no
+ *  creating write (nothing to prove). The SINGLE source of the leg-selection
+ *  logic — `generateTsProof` (the .mts marker) and `proofLegsIndex` (the
+ *  per-domain index) both call this, so the offline lane proves any domain the
+ *  same way the generated proof proves its primary one. */
+export function proofLegsForModule(mod: DomainModule): ProofLegs | null {
+  const createDir = (mod.directives as Directive<unknown>[]).find(
+    (d) => d?.marker === "creates" && typeof d.payloadSchema === "object",
+  );
+  if (createDir === undefined) return null;
+  const domain = mod.domain ?? mod.name;
+  const agg = (mod.aggregates as AggregateHandle[]).find((a) => a.id === createDir.aggregateId);
+  if (agg === undefined) return null;
+  const synth = synthesizePayload(createDir.payloadSchema as z.ZodTypeAny, `${domain}/${createDir.id}`);
+  const mintField = mintedCreateField(createDir, agg);
+  const baseValue: Record<string, unknown> = { ...synth.value };
+  if (mintField !== undefined) delete baseValue[mintField];
+  const query = ((mod.queries ?? []) as QueryDecl[]).find(
+    (q) => q.returns === agg.id && q.key.length > 0 && q.key.every((k) => !k.includes(".") && baseValue[k] !== undefined),
+  );
+  const count = (mod.counts ?? [])
+    .map((raw) => finishCount(raw))
+    .find((c) => c.of === agg.id && (c as { where?: unknown }).where == null && (c.by == null || baseValue[c.by] !== undefined));
+  return {
+    domain,
+    directiveId: createDir.id,
+    aggregateId: agg.id,
+    payload: baseValue,
+    autoStamped: synth.autoStamped,
+    ...(mintField !== undefined ? { mintField } : {}),
+    ...(query ? { query: { id: query.id, params: Object.fromEntries(query.key.map((k) => [k, baseValue[k]])) } } : {}),
+    ...(count ? { count: { id: count.id, group: count.by != null ? String(baseValue[count.by]) : "" } } : {}),
+  };
+}
+
+/** The per-domain legs index for `build/<name>.proof-legs.json` — every domain
+ *  with a creating write, plus the default (the first, which the .mts proves).
+ *  `githolon proof [--domain <key>]` runs any of these offline. */
+export function proofLegsIndex(modules: readonly DomainModule[]): { default: string; domains: Record<string, ProofLegs> } | null {
+  const domains: Record<string, ProofLegs> = {};
+  let first: string | undefined;
+  for (const mod of modules) {
+    // FAIL SOFT per-module: a sibling domain whose payload can't be synthesized
+    // (an exotic zod shape synthesizePayload throws on) must not lose the index
+    // for the domains that DO synthesize — skip it, keep the rest.
+    let legs: ProofLegs | null;
+    try {
+      legs = proofLegsForModule(mod);
+    } catch {
+      continue;
+    }
+    if (legs === null) continue;
+    domains[legs.domain] = legs;
+    if (first === undefined) first = legs.domain;
+  }
+  return first === undefined ? null : { default: first, domains };
+}
+
 export function generateTsProof(modules: readonly DomainModule[], opts: TsProofOptions): string {
   // The proof drives the FIRST domain that has a creating write — without one
   // there is nothing to author, so there is nothing to prove.
@@ -203,7 +274,11 @@ export function generateTsProof(modules: readonly DomainModule[], opts: TsProofO
   const factory = tsClientFactoryName(domain);
   const hashConst = tsHashConstName(opts.packageName);
 
-  const createDir = (mod.directives as Directive<unknown>[]).find((d) => d?.marker === "creates")!;
+  // SAME predicate as the mod selection above AND proofLegsForModule — so the
+  // proof body, its marker, and the index can never describe different directives.
+  const createDir = (mod.directives as Directive<unknown>[]).find(
+    (d) => d?.marker === "creates" && typeof d.payloadSchema === "object",
+  )!;
   const agg = (mod.aggregates as AggregateHandle[]).find((a) => a.id === createDir.aggregateId);
   if (agg === undefined) {
     throw new Error(
@@ -260,17 +335,9 @@ export function generateTsProof(modules: readonly DomainModule[], opts: TsProofO
   const listAccessor = `list${agg.id}s`;
 
   // THE MACHINE-READABLE LEGS (parsed by `githolon`'s offline proof runner —
-  // cli/src/proof_offline.ts — instead of regex-scraping the generated source).
-  const legsMarker = JSON.stringify({
-    domain,
-    directiveId: createDir.id,
-    aggregateId: agg.id,
-    payload: baseValue,
-    autoStamped: synth.autoStamped,
-    ...(mintField !== undefined ? { mintField } : {}),
-    ...(query && queryParamsObj ? { query: { id: query.id, params: queryParamsObj } } : {}),
-    ...(count ? { count: { id: count.id, group: count.by != null ? String(baseValue[count.by]) : "" } } : {}),
-  });
+  // cli/src/proof_offline.ts). The ONE leg-synthesis (`proofLegsForModule`) feeds
+  // both this marker and the per-domain `proof-legs.json` index, so they never drift.
+  const legsMarker = JSON.stringify(proofLegsForModule(mod));
 
   let step = 0;
   const n = () => ++step;

package/src/compile_package_main.ts

@@ -104,7 +104,7 @@ import {
 } from "./stable_ids.js";
 import type { UsdLayer } from "./usd.js";
 import { generateTsClient, tsClientFactoryName } from "./codegen_ts.js";
-import { generateTsProof } from "./codegen_proof.js";
+import { generateTsProof, proofLegsIndex } from "./codegen_proof.js";
 
 const DSL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -1287,10 +1287,20 @@ async function main(): Promise<void> {
   //        synthesizer can't sample yet still compiles — the skip names its remedy.
   let proofPath: string | undefined;
   let proofSkip: string | undefined;
+  let proofDomains: string[] = [];
   try {
     const proofSrc = generateTsProof(domainModules, { packageName: cfg.name, domainHash });
     proofPath = path.join(outDir, `${cfg.name}.proof.mts`);
     writeFileSync(proofPath, proofSrc, "utf8");
+    // THE PER-DOMAIN LEGS INDEX: every domain with a creating write, so
+    // `githolon proof --domain <key>` proves ANY of them offline (the .mts
+    // proves the primary one live). A multi-domain package no longer locks the
+    // proof to whichever domain happens to be first.
+    const legsIndex = proofLegsIndex(domainModules);
+    if (legsIndex !== null) {
+      writeFileSync(path.join(outDir, `${cfg.name}.proof-legs.json`), JSON.stringify(legsIndex, null, 2) + "\n", "utf8");
+      proofDomains = Object.keys(legsIndex.domains);
+    }
   } catch (e) {
     proofSkip = (e as Error).message;
   }
@@ -1385,6 +1395,9 @@ async function main(): Promise<void> {
     console.log(`prove it OFFLINE first: npx githolon proof        # the generated proof's offline legs on a LOCAL holon (no cloud workspace)`);
     console.log(`  inner loop:           npx githolon dev          # watch -> recompile -> law live locally -> offline proof, on every save`);
     console.log(`  then the cloud loop:  npx githolon proof --live # throwaway workspace, retired on exit (--keep keeps it)`);
+    if (proofDomains.length > 1) {
+      console.log(`  this package proves ${proofDomains.length} domains (${proofDomains.join(", ")}) — default '${proofDomains[0]}'; pick another: npx githolon proof --domain <key>`);
+    }
   } else {
     console.log(`prove it: npm run e2e   # offline write -> sync -> admission -> cloud query, live`);
   }

package/src/wire_encode.ts

@@ -139,9 +139,12 @@ function encodeKernelFieldOp(op: FieldOp, field: Field | undefined): WireFieldOp
  * to test domain LIFECYCLE.
  *
  * For a KERNEL-BACKED local harness — admission through the real gate, folds,
- * reads, the whole lifecycle on the same engine plane the cloud edge runs — use
- * the CLI: `githolon proof` (the generated proof's offline legs on a local
- * holon) and `githolon dev` (the watch→recompile→law-live→proof inner loop).
+ * reads, minted ids, the whole lifecycle on the same engine plane the cloud
+ * edge runs — use the CLI, NOT this function:
+ *   • `githolon dev --once` — ONE compile → law-live-locally → proof cycle, then
+ *     exit (the CI/smoke lane for lifecycle + id-mint tests — a non-zero exit
+ *     names the jam). `githolon dev` (no flag) is the same on a watch loop.
+ *   • `githolon proof` — the generated proof's offline legs on a local holon.
  * Those mint ids, run the gate, and fold — exactly what this function does NOT.
  */
 export function executeDirectiveToIntent<P>(