@githolon/dsl 0.59.0 → 0.59.1

package/dart_types/LICENSE

@@ -0,0 +1,45 @@
+# Nomos Pre-Release License (v1)
+
+Copyright © 2026 Captain App Ltd. All rights reserved.
+
+This is a pre-release of Nomos. This license gives you what you need to BUILD
+with it; we keep the rest for now.
+
+## You may
+
+- install and use these packages to author Nomos domains, compile them, and
+  deploy them to Nomos Cloud or any Nomos instance Captain App operates or
+  authorizes;
+- build, run, and ship applications on top of them — including commercial ones;
+- keep everything that's yours: code you write, and everything these tools
+  generate FOR you (scaffolds from `create-githolon` / `githolon generate`, generated
+  clients, compiled domain packages) carries NO restriction from us — it is
+  yours outright.
+
+## You may not
+
+- redistribute these packages or their source, in whole or in part, outside
+  your team;
+- modify them or build derivative tools, SDKs, or runtimes from their source;
+- offer the Nomos runtime, or anything materially similar, as a hosted service;
+- reverse-engineer the holon wasm runtime.
+
+## Data retention
+
+This is a pre-release we are actively evaluating. Workspaces you retire stop
+counting toward your quota but are NOT deleted: **we retain all workspace data
+(ledgers, law, intents) and may examine it to evaluate how the product is
+used.** Don't put anything in a pre-release workspace you wouldn't want the
+builders to read. If you need something truly expunged, ask:
+jack@captainapp.co.uk.
+
+## The rest
+
+Provided **as is**, with no warranty of any kind; to the maximum extent
+permitted by law, Captain App Ltd accepts no liability arising from your use.
+This license terminates automatically if you breach it.
+
+Want the kernel source, broader rights, or to do something this doesn't cover?
+**Ask: jack@captainapp.co.uk.** The plan is to open Nomos up gradually, with
+the people actually using it — telling us what you're building is how that
+happens faster.

package/dart_types/README.md

@@ -0,0 +1,15 @@
+# nomos_types
+
+The pure data core for Nomos Dart frontends — kernel wire types, the offer codec,
+the `NomosReads` typed-read seam, aggregate metadata, schema validation, and the
+structured error surface. **No transport, no bridge, no runtime**: this package is
+safe to depend on from UI code.
+
+It is the foundation of the Nomos layered-packages emit (`dart.packages` in
+`nomos-compile`): generated per-domain TYPES packages depend only on `nomos_types`,
+while the effectful runtime rides `nomos_client` (which depends on and re-exports
+this package). The layering line: generated types may flow to the UI; generated
+clients/runtime may not.
+
+Part of [Nomos](https://github.com/Captain-App/nomos2) — a local-first domain
+runtime where every peer runs the same deterministic wasm holon.

package/package.json

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

@@ -1878,6 +1878,10 @@ export interface ProofLegs {
    *  When this domain is itself the BORN child's law (no standalone create), the index also registers the
    *  child domain key pointing at the SAME leg, so `proof --domain <child>` resolves through the parent birth. */
   readonly childBirth?: ChildBirthLeg;
+  /** ALL child-birth legs, when this domain declares MORE THAN ONE `.births()` directive (`childBirth` is
+   *  always the first of these). Emitted only in the >1 case so single-birth output is byte-unchanged;
+   *  readers should treat `childBirths ?? (childBirth ? [childBirth] : [])` as the canonical set. */
+  readonly childBirths?: readonly ChildBirthLeg[];
   /** THE RELATION-BOOTSTRAP LEG — present iff this domain has a `.requires(R)`-gated directive AND a
    *  discoverable granter of R (a `.grants(R)` marker, or a plan-probed granting `writeTuple`). Proves the
    *  gated write SUCCEEDS once R is granted (the seed-then-prove positive). Additive: absent ⇒ older/ungated. */
@@ -2014,9 +2018,9 @@ export function proofLegsForModule(mod: DomainModule): ProofLegs | null {
   };
 }
 
-/** The first `.births()` directive in a module (with a synthesizable payload), or undefined. */
-function birthDirectiveOf(mod: DomainModule): Directive<unknown> | undefined {
-  return (mod.directives as Directive<unknown>[]).find((d) => d?.birthsChild === true && typeof d.payloadSchema === "object");
+/** Whether a module carries any `.births()` directive (with a synthesizable payload). */
+function hasBirthDirective(mod: DomainModule): boolean {
+  return (mod.directives as Directive<unknown>[]).some((d) => d?.birthsChild === true && typeof d.payloadSchema === "object");
 }
 
 /** Build the legs for ONE domain module — every leg it carries (compile-valid always; standalone-provable
@@ -2034,10 +2038,11 @@ export function legsForDomain(mod: DomainModule, modules: readonly DomainModule[
   } catch {
     standalone = null;
   }
-  // The child-birth leg (when the domain has a `.births()` directive) — discovered by running its plan.
-  const birthDir = birthDirectiveOf(mod);
-  const childBirth = birthDir !== undefined ? allBirths.find((b) => b.parentDomain === domain && b.birthDirectiveId === birthDir.id) : undefined;
-  const childBirthWithSetup = childBirth !== undefined ? attachParentSetup(childBirth, allBirths) : undefined;
+  // The child-birth legs (one per `.births()` directive) — discovered by running each plan. A parent
+  // with SEVERAL births (co2: birthCatalogueWorkspace + birthEstateWorkspace) keeps EVERY leg; keeping
+  // only the first left the other children compile-valid-only (unprovable through their birth).
+  const childBirths = allBirths.filter((b) => b.parentDomain === domain).map((b) => attachParentSetup(b, allBirths));
+  const childBirthWithSetup = childBirths[0];
 
   // The relation-bootstrap leg (when the domain has a `.requires(R)`-gated directive AND a discoverable
   // granter of R). FAIL SOFT: no granter → no leg (the negative conformance leg still covers the gate).
@@ -2120,6 +2125,7 @@ export function legsForDomain(mod: DomainModule, modules: readonly DomainModule[
         }
       : {}),
     ...(childBirthWithSetup !== undefined ? { childBirth: childBirthWithSetup } : {}),
+    ...(childBirths.length > 1 ? { childBirths } : {}),
     ...(relationBootstrap !== undefined ? { relationBootstrap } : {}),
   };
 }
@@ -2142,17 +2148,18 @@ export function proofLegsIndex(modules: readonly DomainModule[]): { default: str
   // no standalone leg of its own. Register that child domain key pointing at the PARENT's child-birth leg
   // (so `proof --domain estate` proves it THROUGH the birth that installs it — the only way it comes to be).
   for (const legs of [...Object.values(domains)]) {
-    const cb = legs.childBirth;
-    if (cb === undefined) continue;
-    const existing = domains[cb.childDomain];
-    if (existing === undefined) {
-      // A pure child-only domain whose ONLY proof is the parent birth: register it as child-birth-provable.
-      domains[cb.childDomain] = { domain: cb.childDomain, legs: ["compile-valid", "child-birth-provable"], childBirth: cb };
-      if (!order.includes(cb.childDomain)) order.push(cb.childDomain);
-    } else if (existing.childBirth === undefined) {
-      // The child domain ALSO compiled standalone (e.g. it has its own create) — add the child-birth leg to it.
-      const mergedLegs = [...new Set([...(existing.legs ?? ["compile-valid"]), "child-birth-provable" as const])];
-      domains[cb.childDomain] = { ...existing, legs: mergedLegs, childBirth: cb };
+    // EVERY birth leg fans out to its child (a parent with several `.births()` registers each child).
+    for (const cb of legs.childBirths ?? (legs.childBirth !== undefined ? [legs.childBirth] : [])) {
+      const existing = domains[cb.childDomain];
+      if (existing === undefined) {
+        // A pure child-only domain whose ONLY proof is the parent birth: register it as child-birth-provable.
+        domains[cb.childDomain] = { domain: cb.childDomain, legs: ["compile-valid", "child-birth-provable"], childBirth: cb };
+        if (!order.includes(cb.childDomain)) order.push(cb.childDomain);
+      } else if (existing.childBirth === undefined) {
+        // The child domain ALSO compiled standalone (e.g. it has its own create) — add the child-birth leg to it.
+        const mergedLegs = [...new Set([...(existing.legs ?? ["compile-valid"]), "child-birth-provable" as const])];
+        domains[cb.childDomain] = { ...existing, legs: mergedLegs, childBirth: cb };
+      }
     }
   }
   if (order.length === 0) return null;
@@ -2473,7 +2480,7 @@ export function generateTsProof(modules: readonly DomainModule[], opts: TsProofO
   // domain's FULL legs (so the offline runner + the index never describe different directives).
   const hasStandaloneCreate = (m: DomainModule): boolean =>
     (m.directives as Directive<unknown>[]).some((d) => isStandaloneCreate(d));
-  const hasBirth = (m: DomainModule): boolean => birthDirectiveOf(m) !== undefined;
+  const hasBirth = (m: DomainModule): boolean => hasBirthDirective(m);
   const isBootstrapProvable = (m: DomainModule): boolean => {
     try { return discoverRelationBootstrapLeg(m) !== undefined; } catch { return false; }
   };