@githolon/dsl 0.1.2 → 0.1.3

package/package.json

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

@@ -9,7 +9,7 @@
  * TS CLIENT CODEGEN (#10) — the WEB sibling of `codegen_dart.ts`.
  *
  * Dart apps get generated payload classes / read models / typed query accessors;
- * until this file, a web app on `githolonent` hand-typed directive ids and
+ * until this file, a web app on `@githolon/client` hand-typed directive ids and
  * payload shapes against the raw `dispatch()` surface. `generateTsClient(modules,
  * opts)` closes that: ONE generated `.ts` file per package, emitted by
  * `nomos-compile` AFTER the package is hashed (the deployed law's content hash is
@@ -27,7 +27,7 @@
  *   * a CLIENT FACTORY per domain — typed `dispatch` wrappers bound to the baked
  *     domainHash, typed declared-query accessors, and by-id read/watch helpers —
  *     over a STRUCTURAL `NomosHolon` interface, so the file has ZERO imports and
- *     binds to `githolonent`'s `connect()` result (browser or node) as-is.
+ *     binds to `@githolon/client`'s `connect()` result (browser or node) as-is.
  *
  * Like every emitter here: NO FALLBACK. An unsupported zod shape throws at compile
  * time, never degrades to `any` silently.
@@ -219,9 +219,9 @@ export function generateTsClient(modules: readonly DomainModule[], opts: TsClien
   out.push(
     `// AUTO-GENERATED by nomos-compile — typed TS client for package "${opts.packageName}".`,
     `// Regenerated on every compile; do not edit. Zero imports: bind it to any holon`,
-    `// exposing the githolonent surface (the structural NomosHolon below), e.g.`,
+    `// exposing the @githolon/client surface (the structural NomosHolon below), e.g.`,
     `//`,
-    `//   import { connect } from "githolonent";`,
+    `//   import { connect } from "@githolon/client";`,
     `//   import { ${lcFirst(camel(modules[0]?.domain ?? "domain"))}Client } from "./build/${opts.packageName}.client.js";`,
     `//   const holon = await connect({ cloud, workspace, clientId });`,
     `//   const app = ${lcFirst(camel(modules[0]?.domain ?? "domain"))}Client(holon);`,
@@ -232,7 +232,7 @@ export function generateTsClient(modules: readonly DomainModule[], opts: TsClien
     `/** One projection row: the aggregate's wire type, its id, and the folded fields. */`,
     `export interface Row<T> { type: string; id: string; data: T }`,
     ``,
-    `/** The holon surface this client binds to (structurally satisfied by githolonent). */`,
+    `/** The holon surface this client binds to (structurally satisfied by @githolon/client). */`,
     `export interface NomosHolon {`,
     `  dispatch(domain: string, directiveId: string, payload: unknown, opts: { domainHash: string }): Promise<string>;`,
     `  query(queryId: string, params?: Record<string, unknown>): Promise<unknown>;`,

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 };
 }