githolon 0.30.0 → 0.31.0

package/dist/cli.mjs

@@ -1488,7 +1488,14 @@ function parseOfflineLegs(proofSource) {
     ...countLeg !== void 0 ? { count: countLeg } : {}
   };
 }
-function runOfflineLegs(eng, ws, lawHash, legs, frameworkHash) {
+async function mountIsolatedProofWs(eng, baseWs, lawHash, deployUsda) {
+  const iso = `${baseWs}-rb`;
+  await mountFresh(eng, iso);
+  author(eng, iso, "bootstrap", "installDomain", installPayload(eng.hashes.nomos, eng.nomosPkg, "githolon-proof"), "");
+  author(eng, iso, "nomos", "installDomain", installPayload(lawHash, deployUsda, "githolon-proof"), eng.hashes.nomos);
+  return iso;
+}
+async function runOfflineLegs(eng, ws, lawHash, legs, frameworkHash, deployUsda) {
   const t0 = performance.now();
   const done = (ok, lines2, error) => ({
     ok,
@@ -1532,7 +1539,11 @@ function runOfflineLegs(eng, ws, lawHash, legs, frameworkHash) {
     if (!v.ok) return done(false, lines, v.error);
   }
   if (legs.relationBootstrap !== void 0) {
-    const v = runRelationBootstrapLeg(eng, ws, lawHash, legs.relationBootstrap);
+    let rbWs = ws;
+    if (legs.relationBootstrap.bornContext === void 0 && deployUsda !== void 0) {
+      rbWs = await mountIsolatedProofWs(eng, ws, lawHash, deployUsda);
+    }
+    const v = runRelationBootstrapLeg(eng, rbWs, lawHash, legs.relationBootstrap);
     lines.push(...v.legs);
     if (!v.ok) return done(false, lines, v.error);
   }
@@ -1651,11 +1662,28 @@ function runRelationBootstrapLeg(eng, ws, lawHash, rb) {
   const grantedRelation = rb.grantedRelation ?? rb.relation;
   const computed = grantedRelation !== rb.relation;
   const speculative = rb.seedSpeculative === true;
-  const grantPayload = { ...rb.grantPayload };
-  const overwrite = /* @__PURE__ */ new Set([...rb.grantSubjectFields, ...rb.grantGrantedByFields]);
-  for (const k of Object.keys(grantPayload)) {
-    if (overwrite.has(k) || /^(subject|principal|grantedBy|grantee|member|user|owner)$/i.test(k)) grantPayload[k] = ACTOR;
+  if (rb.bornContext !== void 0) {
+    return runBornContextLeg(eng, ws, lawHash, rb, ACTOR, stamp);
+  }
+  const seatActorFields = (payload, routed) => {
+    const set = new Set(routed);
+    for (const k of Object.keys(payload)) {
+      if (set.has(k) || /^(subject|principal|grantedBy|grantee|member|user|owner|founder)$/i.test(k)) payload[k] = ACTOR;
+    }
+  };
+  for (const seed of rb.prerequisiteSeeds ?? []) {
+    const seedPayload = { ...seed.payload };
+    seatActorFields(seedPayload, []);
+    for (const f of seed.autoStamped) seedPayload[f] = stamp;
+    const seedRes = author(eng, ws, rb.domain, seed.directiveId, seedPayload, lawHash, actorOpts);
+    if (seedRes.ok === false) {
+      lines.push(`\u2013 relation-bootstrap leg SKIPPED (prerequisite-seed chain) \u2014 the prerequisite seed ${rb.domain}/${seed.directiveId} REFUSED with a synthesized payload (${seedRes.error ?? "refused"}); the granter ${rb.grantDirectiveId}'s prerequisite can't be established standalone \u2014 prove ${rb.gatedDirectiveId} via a birth genesis / by hand`);
+      return done(true);
+    }
+    lines.push(`\u2713 relation bootstrap (prerequisite) \u2014 ${rb.domain}/${seed.directiveId} established (as founder ${ACTOR}) before the grant`);
   }
+  const grantPayload = { ...rb.grantPayload };
+  seatActorFields(grantPayload, [...rb.grantSubjectFields, ...rb.grantGrantedByFields]);
   for (const f of rb.grantAutoStamped) grantPayload[f] = stamp;
   const grantRes = author(eng, ws, rb.domain, rb.grantDirectiveId, grantPayload, lawHash, actorOpts);
   if (grantRes.ok === false) {
@@ -1681,6 +1709,43 @@ function runRelationBootstrapLeg(eng, ws, lawHash, rb) {
   lines.push(speculative ? `\u2713 relation bootstrap (prove) \u2014 ${rb.domain}/${rb.gatedDirectiveId} authored under the replayed seed (gated write SUCCEEDS \u2014 the REAL kernel gate confirmed the replayed seed establishes authority for "${rb.relation}")` : `\u2713 relation bootstrap (prove) \u2014 ${rb.domain}/${rb.gatedDirectiveId} authored under the seeded holder of "${rb.relation}" (gated write SUCCEEDS once granted)`);
   return done(true);
 }
+function runBornContextLeg(eng, ws, lawHash, rb, ACTOR, stamp) {
+  const t0 = performance.now();
+  const lines = [];
+  const done = (ok, error) => ({ ok, ms: performance.now() - t0, legs: lines, ...error !== void 0 ? { error } : {} });
+  const bc = rb.bornContext;
+  const fw = eng.hashes?.nomos;
+  const actorOpts = { actor: ACTOR };
+  const birthPayload = { ...bc.birthPayload };
+  if (bc.ownerField !== void 0) birthPayload[bc.ownerField] = ACTOR;
+  if (bc.frameworkHashField !== void 0) birthPayload[bc.frameworkHashField] = fw;
+  if (bc.lawHashField !== void 0) birthPayload[bc.lawHashField] = lawHash;
+  for (const f of bc.birthAutoStamped) birthPayload[f] = stamp;
+  const birthRes = author(eng, ws, rb.domain, bc.birthDirectiveId, birthPayload, lawHash, actorOpts);
+  if (birthRes.ok === false) {
+    lines.push(`\u2013 relation-bootstrap leg SKIPPED (layer-4 born-context) \u2014 the self-birth ${rb.domain}/${bc.birthDirectiveId} refused (${birthRes.error ?? "refused"}); could not establish born-genesis authority for "${rb.relation}"`);
+    return done(true);
+  }
+  const bornWs = (birthRes.born ?? []).map((b) => b?.workspace).find((w) => typeof w === "string" && w.length > 0);
+  if (bornWs === void 0) {
+    lines.push(`\u2013 relation-bootstrap leg SKIPPED (layer-4 born-context) \u2014 the self-birth ${rb.domain}/${bc.birthDirectiveId} admitted but spawned no workspace (the genesis did not fold); "${rb.relation}" authority not established`);
+    return done(true);
+  }
+  lines.push(`\u2713 relation bootstrap (born-context) \u2014 birthed ${bornWs} via ${rb.domain}/${bc.birthDirectiveId}; its genesis (${bc.seatsViaDirectiveId}) seated "${rb.relation}" for the owner ${ACTOR}`);
+  const gatedPayload = { ...rb.gatedPayload };
+  for (const k of Object.keys(gatedPayload)) {
+    if (/^(subject|principal|owner|ownerSubject|grantee|member|user)$/i.test(k)) gatedPayload[k] = ACTOR;
+  }
+  for (const f of rb.gatedAutoStamped) gatedPayload[f] = stamp;
+  if (rb.gatedMintField !== void 0 && rb.gatedAggregateId !== void 0) gatedPayload[rb.gatedMintField] = mintId(eng, rb.gatedAggregateId);
+  const gatedRes = author(eng, bornWs, rb.domain, rb.gatedDirectiveId, gatedPayload, lawHash, actorOpts);
+  if (gatedRes.ok === false) {
+    lines.push(`\u2013 relation-bootstrap leg SKIPPED (layer-4 born-context) \u2014 dispatching ${rb.domain}/${rb.gatedDirectiveId} .requires("${rb.relation}") inside the born ${bornWs} as ${ACTOR} was REFUSED on the real gate (${gatedRes.error ?? "refused"}); the born genesis did not establish the authority the gate needs`);
+    return done(true);
+  }
+  lines.push(`\u2713 relation bootstrap (prove) \u2014 ${rb.domain}/${rb.gatedDirectiveId} authored INSIDE the born ${bornWs} as the genesis-established owner (gated write SUCCEEDS \u2014 the REAL kernel gate confirmed the born genesis seats "${rb.relation}")`);
+  return done(true);
+}
 function actorFromPayload(payload, field) {
   if (field === void 0) return void 0;
   const value = payload[field];
@@ -1722,7 +1787,7 @@ async function runOfflineProofStandalone(proofPath, cloud, domain) {
   await mountFresh(eng, ws);
   author(eng, ws, "bootstrap", "installDomain", installPayload(eng.hashes.nomos, eng.nomosPkg, "githolon-proof"), "");
   author(eng, ws, "nomos", "installDomain", installPayload(lawHash, deployBody.packageUsda, "githolon-proof"), eng.hashes.nomos);
-  const v = runOfflineLegs(eng, ws, lawHash, legs, eng.hashes.nomos);
+  const v = await runOfflineLegs(eng, ws, lawHash, legs, eng.hashes.nomos, deployBody.packageUsda);
   for (const l of v.legs) console.log(l);
   if (!v.ok) {
     console.error(`\u2717 ${v.error}`);
@@ -2186,7 +2251,7 @@ async function runProofCycle(s, cwd, deployBody, installedBy) {
     await mountFresh(s.eng, scratch);
     author(s.eng, scratch, "bootstrap", "installDomain", installPayload(s.eng.hashes.nomos, s.eng.nomosPkg, installedBy), "");
     author(s.eng, scratch, "nomos", "installDomain", installPayload(s.lawHash, deployBody.packageUsda, installedBy), s.eng.hashes.nomos);
-    return runOfflineLegs(s.eng, scratch, s.lawHash, legs);
+    return await runOfflineLegs(s.eng, scratch, s.lawHash, legs, s.eng.hashes.nomos, deployBody.packageUsda);
   } catch (e) {
     return { ok: false, ms: 0, legs: [], error: String(e.message ?? e) };
   } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "githolon",
-  "version": "0.30.0",
+  "version": "0.31.0",
   "type": "module",
   "description": "githolon — the Nomos developer CLI: Rails-style generators for @githolon/dsl domains + the package compiler. Kernel-independent.",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/client": "^0.30.0",
-    "@githolon/dsl": "^0.30.0",
+    "@githolon/client": "^0.31.0",
+    "@githolon/dsl": "^0.31.0",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {