@githolon/dsl 0.119.12 → 0.119.28

package/compile_package.mjs

@@ -6,7 +6,7 @@
 // If a file isn't this / hosting this / authoring for this / proving this — it's gone.
 
 // `nomos-compile` / `holon-compile` — the thin launcher: resolve `tsx` (the
-// caller's, else the DSL's own dependency) and run `src/compile_package_main.ts`
+// DSL's own dependency, else the caller's) and run `src/compile_package_main.ts`
 // through its ESM loader IN THIS PROCESS (the main dynamically imports the caller's
 // TS domain modules, which needs the tsx loader). tsx is a regular dependency of
 // @githolon/dsl, so a bare `npx githolon compile` / `npx nomos-compile` works with
@@ -29,82 +29,88 @@ import {
 const DSL_DIR = path.dirname(fileURLToPath(import.meta.url));
 const MAIN = path.join(DSL_DIR, "src", "compile_package_main.ts");
 
-const args = process.argv.slice(2);
-const configArg = args.find((argument) => !argument.startsWith("--")) ?? "nomos.project.ts";
-const configPath = path.resolve(process.cwd(), configArg);
-const cacheable =
-  existsSync(configPath) &&
-  !args.includes("--preflight") &&
-  !args.includes("--analyze") &&
-  process.env.NOMOS_PREFLIGHT !== "1" &&
-  process.env.NOMOS_ANALYZE !== "1";
-const argumentIdentity = [
-  ...args,
-  `NOMOS_COMPACT=${process.env.NOMOS_COMPACT ?? ""}`,
-  `NOMOS_REQUIRE_USDCAT=${process.env.NOMOS_REQUIRE_USDCAT ?? ""}`,
-  `NOMOS_USDCAT=${process.env.NOMOS_USDCAT ?? ""}`,
-].join("\n");
-if (cacheable) {
-  const proofPath = compileProofPath(process.cwd(), configPath);
-  const inputs = compileInputs({
-    cwd: process.cwd(),
-    dslDir: DSL_DIR,
-    configPath,
-    argumentIdentity,
-    importedSources: recordedImportedSources(proofPath),
-  });
-  const proof = readCompileProof({ proofPath, inputs });
-  if (proof !== undefined) {
-    console.log(`nomos-compile: ${proof.name} unchanged`);
-    // The law identity is the unit set (CAP-773): the compile wrote it beside the package it proves.
-    const unitSet = (() => {
-      try {
-        return readFileSync(proof.law.replace(/\.law\.usdz$/u, ".units.sha256"), "utf8").trim();
-      } catch {
-        return "(unreadable — recompile)";
-      }
-    })();
-    console.log(`  law        unit set ${unitSet}`);
-    console.log(`  package    ${proof.domainHash} — package — not what targets serve (${path.relative(process.cwd(), proof.law)})`);
-    console.log(`  verify     ✓ typed USDA content proof covers compiler, authored inputs and ${proof.outputCount} generated artifacts`);
-    process.exit(0);
+async function main() {
+  const args = process.argv.slice(2);
+  const configArg = args.find((argument) => !argument.startsWith("--")) ?? "nomos.project.ts";
+  const configPath = path.resolve(process.cwd(), configArg);
+  const cacheable =
+    existsSync(configPath) &&
+    !args.includes("--preflight") &&
+    !args.includes("--analyze") &&
+    process.env.NOMOS_PREFLIGHT !== "1" &&
+    process.env.NOMOS_ANALYZE !== "1";
+  const argumentIdentity = [
+    ...args,
+    `NOMOS_COMPACT=${process.env.NOMOS_COMPACT ?? ""}`,
+    `NOMOS_REQUIRE_USDCAT=${process.env.NOMOS_REQUIRE_USDCAT ?? ""}`,
+    `NOMOS_USDCAT=${process.env.NOMOS_USDCAT ?? ""}`,
+  ].join("\n");
+  if (cacheable) {
+    const proofPath = compileProofPath(process.cwd(), configPath);
+    const inputs = compileInputs({
+      cwd: process.cwd(),
+      dslDir: DSL_DIR,
+      configPath,
+      argumentIdentity,
+      importedSources: recordedImportedSources(proofPath),
+    });
+    const proof = readCompileProof({ proofPath, inputs });
+    if (proof !== undefined) {
+      console.log(`nomos-compile: ${proof.name} unchanged`);
+      // The law identity is the unit set (CAP-773): the compile wrote it beside the package it proves.
+      const unitSet = (() => {
+        try {
+          return readFileSync(proof.law.replace(/\.law\.usdz$/u, ".units.sha256"), "utf8").trim();
+        } catch {
+          return "(unreadable — recompile)";
+        }
+      })();
+      console.log(`  law        unit set ${unitSet}`);
+      console.log(`  package    ${proof.domainHash} — package — not what targets serve (${path.relative(process.cwd(), proof.law)})`);
+      console.log(`  verify     ✓ typed USDA content proof covers compiler, authored inputs and ${proof.outputCount} generated artifacts`);
+      // Let Node drain normally. Forcing shutdown here can deadlock V8
+      // background compilation against a collection waiting on this thread.
+      return;
+    }
+    process.env.NOMOS_COMPILE_PROOF_PATH = proofPath;
+    process.env.NOMOS_COMPILE_ARGUMENT_IDENTITY = argumentIdentity;
   }
-  process.env.NOMOS_COMPILE_PROOF_PATH = proofPath;
-  process.env.NOMOS_COMPILE_ARGUMENT_IDENTITY = argumentIdentity;
-}
 
-/** Resolve a dependency's package dir from `fromDir`, walking Node's resolver. */
-function resolvePkgDir(name, fromDir) {
-  try {
-    const req = createRequire(pathToFileURL(path.join(fromDir, "noop.js")));
-    return path.dirname(req.resolve(`${name}/package.json`));
-  } catch {
-    return undefined;
+  /** Resolve a dependency's package dir from `fromDir`, walking Node's resolver. */
+  function resolvePkgDir(name, fromDir) {
+    try {
+      const req = createRequire(pathToFileURL(path.join(fromDir, "noop.js")));
+      return path.dirname(req.resolve(`${name}/package.json`));
+    } catch {
+      return undefined;
+    }
   }
-}
 
-const tsxDir = resolvePkgDir("tsx", process.cwd()) ?? resolvePkgDir("tsx", DSL_DIR);
-if (!tsxDir) {
-  console.error("nomos-compile: tsx not found — reinstall @githolon/dsl (tsx is one of its dependencies)");
-  process.exit(1);
+  const tsxDir = resolvePkgDir("tsx", DSL_DIR) ?? resolvePkgDir("tsx", process.cwd());
+  if (!tsxDir) {
+    console.error("nomos-compile: tsx not found — reinstall @githolon/dsl (tsx is one of its dependencies)");
+    process.exit(1);
+  }
+  const tsxApi = JSON.parse(readFileSync(path.join(tsxDir, "package.json"), "utf8")).exports?.["./esm/api"];
+  const tsxApiEntry = path.join(
+    tsxDir,
+    (typeof tsxApi === "string" ? tsxApi : tsxApi?.import?.default ?? tsxApi?.import ?? tsxApi?.default) ?? "dist/esm/api/index.mjs"
+  );
+
+  // Global hooks (not a namespaced `tsImport`): the compiler's `import.meta.url` and every
+  // `createRequire` must stay plain file URLs, exactly as under the tsx CLI.
+  // The compile's authored import closure (including modules outside the project directory) is
+  // collected here and recorded in the compile proof, so editing any of them invalidates it.
+  const importedSources = new Set();
+  globalThis[Symbol.for("nomos.compile.importedSources")] = importedSources;
+  const { register } = await import(pathToFileURL(tsxApiEntry).href);
+  register({
+    onImport(url) {
+      const file = authoredImport(url, DSL_DIR);
+      if (file !== undefined) importedSources.add(file);
+    },
+  });
+  await import(pathToFileURL(MAIN).href);
 }
-const tsxApi = JSON.parse(readFileSync(path.join(tsxDir, "package.json"), "utf8")).exports?.["./esm/api"];
-const tsxApiEntry = path.join(
-  tsxDir,
-  (typeof tsxApi === "string" ? tsxApi : tsxApi?.import?.default ?? tsxApi?.import ?? tsxApi?.default) ?? "dist/esm/api/index.mjs"
-);
 
-// Global hooks (not a namespaced `tsImport`): the compiler's `import.meta.url` and every
-// `createRequire` must stay plain file URLs, exactly as under the tsx CLI.
-// The compile's authored import closure (including modules outside the project directory) is
-// collected here and recorded in the compile proof, so editing any of them invalidates it.
-const importedSources = new Set();
-globalThis[Symbol.for("nomos.compile.importedSources")] = importedSources;
-const { register } = await import(pathToFileURL(tsxApiEntry).href);
-register({
-  onImport(url) {
-    const file = authoredImport(url, DSL_DIR);
-    if (file !== undefined) importedSources.add(file);
-  },
-});
-await import(pathToFileURL(MAIN).href);
+await main();

package/compile_proof.d.mts

@@ -1,3 +1,4 @@
+export function compilerPackageManifest(name: string, from: NodeJS.Require): string;
 export interface CompileProofInputs {
   readonly authoring: readonly { readonly path: string; readonly sha256: string }[];
   readonly compiler: readonly { readonly path: string; readonly sha256: string }[];

package/compile_proof.mjs

@@ -68,6 +68,22 @@ function inventoryIdentity(kind, entries) {
   return hash.digest("hex");
 }
 
+export function compilerPackageManifest(name, from) {
+  try { return from.resolve(`${name}/package.json`); }
+  catch {
+    // Protobuf deliberately does not export package.json. Follow its actual entry,
+    // rather than assuming a hoisted node_modules layout.
+    let directory = path.dirname(from.resolve(name));
+    while (true) {
+      const file = path.join(directory, "package.json");
+      if (existsSync(file) && JSON.parse(readFileSync(file, "utf8")).name === name) return file;
+      const parent = path.dirname(directory);
+      if (parent === directory) throw new Error(`Missing manifest for ${name}`);
+      directory = parent;
+    }
+  }
+}
+
 function dependencyPackageFiles(dslDir, cwd) {
   const files = [];
   // These packages contribute executable bytes or generated bindings to compiler output.
@@ -77,20 +93,30 @@ function dependencyPackageFiles(dslDir, cwd) {
     "@bufbuild/protobuf",
     "@bufbuild/protoc-gen-es",
     "esbuild",
+    "fflate",
     "tsx",
     "typescript",
     "zod",
   ]) {
-    for (const base of [cwd, dslDir]) {
+    for (const base of [dslDir, cwd]) {
       try {
         const request = createRequire(pathToFileURL(path.join(base, "noop.js")));
-        files.push(request.resolve(`${name}/package.json`));
-        break;
+        files.push(compilerPackageManifest(name, request));
+        // Keep tenant copies too: authored schemas may import their own dependencies.
       } catch {
         // The real compiler names a missing dependency after a proof miss.
       }
     }
   }
+  // protoc-gen-es resolves its own exact plugin/runtime, which may be nested when the
+  // application deliberately uses a different Protobuf toolchain.
+  try {
+    const compiler = createRequire(path.join(dslDir, "package.json"));
+    const generator = compiler.resolve("@bufbuild/protoc-gen-es/package.json");
+    const plugin = createRequire(generator).resolve("@bufbuild/protoplugin/package.json");
+    files.push(plugin, compilerPackageManifest("@bufbuild/protobuf", createRequire(generator)),
+      compilerPackageManifest("@bufbuild/protobuf", createRequire(plugin)));
+  } catch { /* The canonical toolchain check reports missing dependencies after a proof miss. */ }
   return files;
 }
 

package/dart/CHANGELOG.md

@@ -1,3 +1,92 @@
+## 0.70.27
+
+- The bundled Node runner names the @githolon/runtime release it was built from; it now carries the runtime that accompanies native hosts 0.69.3.
+
+## 0.70.26
+
+- Keep a first write's enrolment convergence prioritised after placement discovery completes.
+
+- Bound speculative connection handshakes while retaining reserved capacity for pending reads and writes.
+
+- Wait for the parent birth receipt before enrolling a newborn workspace.
+
+- Preserve interactive correspondence capacity when speculative follows announce new frontiers.
+
+- Publish the first write immediately after device enrolment completes.
+
+## 0.70.25
+
+- Bound background replication and preserve capacity for interactive writes; enrol newborn workspaces after provider custody is observed.
+
+## 0.70.24
+
+- Preserve the first call while an accepted device enrolment converges locally, including when console preparation consumed the initial wait window.
+- Receive the proven remote suffix for a newborn workspace before attempting full-history recovery.
+
+## 0.70.23
+
+- Carry the runtime scheduling fix for a first write waiting on birth custody and device enrolment.
+
+## 0.70.22
+
+- Carry the newborn custody seal fix for discovery racing its persistence acknowledgement.
+
+## 0.70.21
+
+- Carry the runtime fix that registers locally born children for replica follow and wakes placement discovery after device enrolment.
+
+## 0.70.20
+
+- Bundle the runtime fix for cold checkpoint custody and pending stream cleanup on peer shutdown.
+
+## 0.70.19
+
+- Restage the bundled runtime with the coordinated compiler release that fixes cached compile process completion.
+
+## 0.70.18
+
+- Restage the bundled runtime with the coordinated compiler release that compacts generated Dart analysis roots.
+
+## 0.70.17
+
+- Bundle the isolated law-preparation worker with the Node test runner so published consumers can prepare current law without source-tree files.
+
+## 0.70.16
+
+- Await read-only current-law preparation during test fixture installation and carry the shared runtime's bounded cold-attachment readiness hold.
+
+## 0.70.15
+
+- Preserve recoverable law-product readiness through repeated cold replay attempts (CAP-992).
+
+## 0.70.14
+
+- Carry the runtime correction for retryable admitted births and observable child custody failures (CAP-960).
+
+Carry the runtime release for the kernel's duplicate-composition fix in frontier transition judgement (CAP-972).
+
+- Carry the framework cut with typed custody-open failures in the next kernel (CAP-975).
+
+- Carry the framework cut with typed missing law-product custody failures in the next kernel (CAP-976).
+
+- Carry the framework runtime cut with canonical Protobuf dependency pins (CAP-979).
+
+- Restage the embedded runtime identity with the framework package cut containing CAP-982 and CAP-983; generated contracts retain published nested value wire allocations.
+
+- Carry the framework cut with atomic per-domain law transitions and retirement protection (CAP-985).
+
+- Carry the framework cut with isolated law preparation and generation-specific product readiness (CAP-986).
+
+- Carry the framework protocol for per-domain plan qualification and detached admission recovery (CAP-987).
+
+- Restage the embedded framework identity with the compiler cut containing CAP-988. The nominal record read fix applies to generated TypeScript clients; Dart already handles this wrapper.
+
+- Carry the kernel correction for query readiness during private child-genesis recovery (CAP-990).
+
+## 0.70.13
+
+- The bundled Node runner names the @githolon/runtime release it was built from; it now carries the runtime that accompanies native hosts 0.69.2.
+
 ## 0.70.12
 
 - Reconcile a completed round's outstanding work and copy repairs before folding application sync status, so a successful reconnect clears the aggregate pending state immediately. Add opt-in session and aggregate sync trace provenance.