@githolon/dsl 0.99.0 → 0.100.0

package/package.json

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

package/src/births.ts

@@ -56,29 +56,8 @@ export function __drainBirths(): BirthRecipe[] {
  * chains carry no key, so they replay byte-green and the kernel does nothing). A plan may birth at most one
  * child per intent (one offer, one defined consequence — the unix model).
  *
- * TO BIRTH A LEAF CHILD RUNNING ITS OWN LAW (a home, an estate child) — copy `framework/home.ts`'s
- * `birthHome`. The recipe is just the two-layer law install + your own seed step; there is NO helper to
- * fabricate it and you do NOT need a new primitive (recursion is the law — a home births children exactly
- * as root births platforms). `buildGenesisChain` is the ONE builder for the PLATFORM shape (it adds the
- * `seedGenesis → grantAdmin → birthCloud` tail); a leaf just omits that tail:
- *
- * ```ts
- * export const birthEstateChild = directive("birthEstateChild")
- *   .creates(EstateChild)
- *   .payload(z.object({ child: z.string(), owner: z.string(),
- *     frameworkHash: z.string(), lawHash: z.string(), bornAt: z.string() }))
- *   .plan((p) => {
- *     const actor = "user:" + p.owner;
- *     birth({ workspace: p.child, genesisChain: [
- *       { domain: "bootstrap", directiveId: "installDomain", actor, payload: { domainHash: p.frameworkHash }, domainHash: p.frameworkHash, domainPackageB64: "" },
- *       { domain: "nomos",     directiveId: "installDomain", actor, payload: { domainHash: p.lawHash },       domainHash: p.lawHash,       domainPackageB64: "" },
- *       { domain: "estate",    directiveId: "seedEstateChild", actor, payload: { owner: p.owner, bornAt: p.bornAt } },
- *     ] });
- *     return [];
- *   })
- *   .births()             // the kernel's run_birth_effect folds the recipe through the CHILD's own gate
- *   .requires("creator"); // grant the parent's owner #creator (self-bound) — the birth authority
- * ```
+ * This is framework implementation plumbing. Application packages declare
+ * `birth(Aggregate, spec)` and never construct a recipe.
  */
 /**
  * A business thing that is important enough to have its own durable, sovereign life.
@@ -112,10 +91,10 @@ export interface BusinessBirthSpec<
   readonly namespace?: string;
 }
 
-/** @internal Framework lane: record an already-lowered child recipe during a directive plan. Tenant law
- * should declare `birth(Aggregate, spec)` and let Nomos own the recipe, identity and recovery machinery. */
+/** @internal Record an already-lowered child recipe during a framework directive plan. Application law
+ * declares `birth(Aggregate, spec)` and leaves the recipe, identity, and recovery machinery to Nomos. */
 export function birth(recipe: BirthRecipe): void;
-/** Tenant lane: declare that one business aggregate is born as a durable workspace root. */
+/** Declare that one business aggregate is given its own durable life. */
 export function birth<P extends Record<string, unknown>, F extends Record<string, Field>>(
   aggregate: AggregateHandle<string, F>,
   spec: BusinessBirthSpec<P, F>,
@@ -184,39 +163,19 @@ interface MintedRef {
 
 /**
  * @deprecated Tenant law should declare `birth(Aggregate, spec)`. This framework helper remains for the
- * built-in workspace laws that implement that declaration.
- *
- * `birth.keyed(...)` — THE way to birth a child workspace. A workspace exists to be USED, and using it means
- * FINDING IT AGAIN, so its name is ALWAYS derived from a `key` the caller owns (a business id, an owner uid)
- * via {@link workspaceNameForKey}. The client re-derives the SAME name with `deriveWorkspaceName(namespace,
- * key)` — so the born workspace is addressable from the key alone, with zero persistence. Same key ⇒ same
- * workspace (re-birth is idempotent). This is the only birth verb you need.
+ * built-in framework laws that implement that declaration.
  *
- * ```ts
- * export const birthEstate = directive("birthEstate")
- *   .creates(EstateBirth)
- *   .payload(z.object({ estateId: z.string(), owner: z.string(), frameworkHash: z.string(), lawHash: z.string(), bornAt: z.string() }))
- *   .plan((p) => {
- *     birth.keyed({ key: p.estateId, namespace: "estate", genesisChain: (ws) => [
- *       { domain: "bootstrap", directiveId: "installDomain", actor: p.owner, payload: { domainHash: p.frameworkHash }, domainHash: p.frameworkHash, domainPackageB64: "" },
- *       { domain: "nomos",     directiveId: "installDomain", actor: p.owner, payload: { domainHash: p.lawHash },       domainHash: p.lawHash,       domainPackageB64: "" },
- *       { domain: "estate",    directiveId: "seedEstate", actor: p.owner, payload: { estateId: p.estateId, workspaceName: ws, bornAt: p.bornAt } },
- *     ] });
- *     return [];
- *   })
- *   .births().requires("estateCreator");
- * // app (Dart / TS): final ws = client.deriveWorkspaceName('estate', estateId); // open it, any time, any device
- * ```
+ * Internal compatibility helper: derives a child address from a stable key. Application packages use
+ * `birth(Aggregate, spec)`; generated clients expose only `birth(businessFacts)`.
  */
 export const birthKeyed = ({
   key,
   namespace,
   genesisChain,
 }: {
-  /** The id you already own that this workspace is FOR (an estateId, an owner uid). The client addresses the
-   *  born workspace by re-deriving its name from this same key — so pick a key the client will have in hand. */
+  /** A stable id from which the framework can re-derive the durable address. */
   key: string;
-  /** The workspace-name namespace (e.g. `"estate"` → `estate-<hash>`). Groups a domain's children. */
+  /** Internal address namespace. */
   namespace: string;
   genesisChain: GenesisChainOrBuilder;
 }): string => {

package/src/business_birth.ts

@@ -258,7 +258,7 @@ export function expandBusinessBirthExports<M extends Record<string, unknown>>(
   if (declarations.length > 1) {
     throw new Error(
       `domain '${domain}' declares ${declarations.length} business births; one generated birth(payload) cannot be ` +
-        "ambiguous — model one workspace root per domain",
+        "ambiguous — model one born aggregate root per domain",
     );
   }
   const lowered = lowerOne(declarations[0]!, domain);

package/src/codegen_dart_client.ts

@@ -348,8 +348,8 @@ export function generateDartBridgeClient(mod: DomainModule, opts: DartBridgeClie
     }).businessBirth;
     if (businessBirth !== undefined) {
       methods.push(
-        `  /// Give one ${businessBirth.aggregateId} its own durable life. Nomos owns identity proof, signer`,
-        `  /// seating, provenance, persistence and recovery; the app supplies only business facts.`,
+        `  /// Give one ${businessBirth.aggregateId} its own durable life. Nomos owns identity, authorship,`,
+        `  /// provenance, persistence and recovery; the app supplies only business facts.`,
         `  Future<NomosRef> birth(${payloadClass} payload) async {`,
         `    final principal = actor ?? bridge.principal;`,
         `    if (principal == null || principal.trim().isEmpty) {`,

package/src/codegen_proof.ts

@@ -1720,6 +1720,9 @@ interface DiscoveredGenesisStep {
  *  synthesized payload (the synthesizer only produces `sample-*` placeholders, which the child install
  *  would refuse). */
 export interface ChildBirthLeg {
+  /** Present for the one application-facing `birth(Aggregate, spec)` declaration. Proof renderers use the
+   *  business noun and keep the lowered framework ceremony out of normal output. */
+  readonly businessAggregateId?: string;
   /** The domain the `.births()` directive lives in. */
   readonly parentDomain: string;
   /** The `.births()` directive id the parent drives to birth the child. */
@@ -2021,9 +2024,11 @@ export function discoverChildBirthLegOrReason(
   if (frameworkHashField !== undefined) delete birthPayload[frameworkHashField];
   if (lawHashField !== undefined) delete birthPayload[lawHashField];
 
+  const businessAggregateId = (birthDir as unknown as { businessBirth?: { aggregateId?: string } }).businessBirth?.aggregateId;
   const leg: ChildBirthLeg = {
     parentDomain,
     birthDirectiveId: birthDir.id,
+    ...(businessAggregateId !== undefined ? { businessAggregateId } : {}),
     birthPayload,
     birthAutoStamped: synth.autoStamped,
     ...(actorField !== undefined ? { birthActorField: actorField } : {}),

package/src/compile_package_main.ts

@@ -2961,19 +2961,16 @@ async function main(): Promise<void> {
     console.log(`    parses on every kernel (larger deploy body; may need the signed-upload deploy lane).`);
   }
   console.log(``);
-  console.log(`deploy (Nomos Cloud):`);
-  console.log(`  githolon login --agent && githolon ws create <ws> && githolon deploy <ws>   # no secret — deploy is OPEN, kernel-judged at the offer gate`);
-  console.log(`  # raw lane: curl -X POST -H 'content-type: application/json' -H 'x-nomos-principal: <your-auth-uid>' \\`);
-  console.log(`  #   --data-binary @${rel(deployPath)} https://nomos.captainapp.co.uk/v2/workspaces/<ws>/domains`);
+  console.log(`your business path:`);
   if (proofPath !== undefined) {
-    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)`);
+    console.log(`  npx githolon proof         # generated birth -> verify -> durable restore -> business read-back`);
+    console.log(`  npx githolon dev           # rerun that proof on every save`);
+    console.log(`  npx githolon proof --live  # the same business proof against Nomos Cloud`);
     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`);
+    console.log(`  add a business birth declaration to generate an end-to-end proof`);
   }
 
   if (analyzeFlag) runDartAnalyze(dartOut);