@githolon/dsl 0.1.1 → 0.1.3

package/LICENSE.md

@@ -12,7 +12,7 @@ with it; we keep the rest for now.
   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-holon` / `holon generate`, generated
+  generate FOR you (scaffolds from `create-githolon` / `githolon generate`, generated
   clients, compiled domain packages) carries NO restriction from us — it is
   yours outright.
 

package/compile_package.mjs

@@ -9,7 +9,7 @@
 // caller's, else the DSL's own dependency) and run `src/compile_package_main.ts`
 // under it (the main dynamically imports the caller's TS domain modules, which
 // needs the tsx ESM loader). tsx is a regular dependency of @githolon/dsl, so a bare
-// `npx holon compile` / `npx nomos-compile` works with zero devDependency setup.
+// `npx githolon compile` / `npx nomos-compile` works with zero devDependency setup.
 // Resolution goes through Node's resolver (createRequire), NOT node_modules/.bin
 // paths — hoisted/workspace installs put the bin shims elsewhere.
 import { execFileSync } from "node:child_process";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@githolon/dsl",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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/compile_package_main.ts

@@ -442,7 +442,24 @@ async function main(): Promise<void> {
   const { manifestsPath } = writeIdentity(identity, outDir);
 
   // ── 4. the one-call deploy body (package + per-workspace manifest overlay) ──
+  // SELF-DESCRIBING: `summary` states what the (otherwise hex-opaque) package
+  // contains — purely derived from the inputs (no timestamps), ignored by the
+  // deploy endpoint, and mirrored as build/<name>.summary.txt for a human or
+  // agent who simply cats the build output.
+  const summary = {
+    package: cfg.name,
+    domainHash,
+    domains: domainModules.map((m) => ({
+      domain: m.domain ?? m.name,
+      aggregates: m.aggregates.map((a) => a.id),
+      directives: m.directives.map((d) => d.id),
+      queries: (m.queries ?? []).map((q) => q.id),
+      counts: (m.counts ?? []).map((c) => c.id),
+      identityHash: identity.hashes[m.domain ?? m.name],
+    })),
+  };
   const deployBody = {
+    summary,
     packageUsda: text,
     readManifest,
     identityManifests: identity.manifests,
@@ -450,6 +467,20 @@ async function main(): Promise<void> {
   };
   const deployPath = path.join(outDir, `${cfg.name}.deploy.json`);
   writeFileSync(deployPath, JSON.stringify(deployBody) + "\n", "utf8");
+  const summaryTxt = [
+    `${cfg.name} — compiled Nomos domain package`,
+    `law (domainHash): ${domainHash}   # sha256(${cfg.name}.package.usda) — content-addressed`,
+    ...summary.domains.flatMap((d) => [
+      `domain '${d.domain}'${d.identityHash ? `  (identity ${d.identityHash.slice(0, 12)}…)` : "  (EXCLUDED from identity manifest)"}`,
+      `  aggregates: ${d.aggregates.join(", ") || "—"}`,
+      `  directives: ${d.directives.join(", ") || "—"}`,
+      `  queries: ${d.queries.join(", ") || "—"}   counts: ${d.counts.join(", ") || "—"}`,
+    ]),
+    `deploy: POST ${cfg.name}.deploy.json to /v1/workspaces/<ws>/domains (or: githolon deploy <ws>)`,
+    `typed client: ${cfg.name}.client.ts — ${cfg.name}Client(holon), law hash baked in`,
+    ``,
+  ].join("\n");
+  writeFileSync(path.join(outDir, `${cfg.name}.summary.txt`), summaryTxt, "utf8");
 
   // ── 5. the typed TS client (#10 — the web sibling of codegen_dart), with the
   //       deployed law's content hash baked in (emitted AFTER the package is hashed) ──

package/src/ops.ts

@@ -93,11 +93,32 @@ function addressOf(agg: Target): { aggregateId: string; aggregateType?: string }
   return { aggregateId: (agg as AggregateHandle).id };
 }
 
-/** Set a scalar field. Field name + value type are both checked. */
+/**
+ * Set a scalar (or map-whole/ref) field. Field name + value type are both checked.
+ *
+ * REFUSES set-kind fields — at the TYPE level (the parameter collapses to an
+ * instructive error string) AND at runtime (so the sealed engine refuses non-TS
+ * callers too): `set()` on an AddWins set would OVERWRITE the merge — concurrent
+ * adds would silently lose. The additive write is {@link addToSet}.
+ */
 export function set<
   A extends Target,
   K extends keyof Fields<A> & string,
->(agg: A, field: K, value: FieldValue<Fields<A>[K]>): FieldOp {
+>(
+  agg: A,
+  field: K &
+    (Fields<A>[K] extends { kind: "set" }
+      ? `TYPE ERROR: '${K}' is a set field — set() would OVERWRITE the merge; use addToSet(handle, "${K}", values)`
+      : K),
+  value: FieldValue<Fields<A>[K]>,
+): FieldOp {
+  const f = (agg as { fields?: Record<string, { kind?: string }> }).fields?.[field];
+  if (f?.kind === "set") {
+    throw new Error(
+      `set('${field}'): '${field}' is a set field — set() would OVERWRITE the merge ` +
+        `(concurrent adds would be lost). Use addToSet(handle, '${field}', values) — the additive write.`,
+    );
+  }
   return { ...addressOf(agg), field, kind: "set", value };
 }