@githolon/dsl 0.61.0 → 0.61.1

package/package.json

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

@@ -116,6 +116,41 @@ const SUBJECT_CANDIDATES: readonly string[] = [`user:${ZERO_UUID}`, `key:${HEX64
  * schema and return the first that validates. If none fits an exotic constraint, fall back to the
  * readable placeholder (behaviour unchanged from before — that directive is proven by hand).
  */
+/** BIRTHS ISOLATION (multi-`.births()` parent): a parent with SEVERAL birth legs (co2:
+ *  birthCatalogueWorkspace + birthEstateWorkspace) synthesizes the SAME readable `sample-<field>` payloads,
+ *  so each leg's plan DERIVES THE SAME child workspace name and the second birth collides on an
+ *  already-born name. Give each leg a distinct child by suffixing its `sample-`-prefixed string values with
+ *  a per-leg discriminator — but ONLY when the suffixed payload STILL satisfies the directive's own schema
+ *  (a constrained field is left untouched, never broken). A single-birth parent is unaffected (no suffix). */
+function uniquifyBirthPayload(
+  payload: Record<string, unknown>,
+  disc: string,
+  schema: z.ZodTypeAny | undefined,
+): Record<string, unknown> {
+  const suffixed: Record<string, unknown> = {};
+  let changed = false;
+  for (const [k, v] of Object.entries(payload)) {
+    if (typeof v === "string" && v.startsWith("sample-")) { suffixed[k] = `${v}-${disc}`; changed = true; }
+    else suffixed[k] = v;
+  }
+  if (!changed) return payload;
+  // Re-validate PER FIELD (the birthPayload has its framework/law-hash fields deleted — they are injected at
+  // runtime — so a whole-payload parse would spuriously fail on the missing required fields). For a
+  // ZodObject we check each suffixed value against ITS OWN field schema; a field whose schema rejects the
+  // suffix (a length/regex bound) is reverted to its original value (never break a constrained field).
+  const shape =
+    schema !== undefined && typeof (schema as { shape?: unknown }).shape === "object"
+      ? ((schema as unknown as { shape: Record<string, z.ZodTypeAny> }).shape)
+      : undefined;
+  for (const [k, v] of Object.entries(suffixed)) {
+    const orig = payload[k];
+    if (v === orig) continue;
+    const fieldSchema = shape?.[k];
+    if (fieldSchema !== undefined && !fieldSchema.safeParse(v).success) suffixed[k] = orig; // revert the constrained field
+  }
+  return suffixed;
+}
+
 function sampleString(zt: z.ZodTypeAny, field: string): string {
   const readable = `sample-${field}`;
   if (zt.safeParse(readable).success) return readable;
@@ -2071,8 +2106,20 @@ export function legsForDomain(mod: DomainModule, modules: readonly DomainModule[
   // The child-birth legs (one per `.births()` directive) — discovered by running each plan. A parent
   // with SEVERAL births (co2: birthCatalogueWorkspace + birthEstateWorkspace) keeps EVERY leg; keeping
   // only the first left the other children compile-valid-only (unprovable through their birth).
-  const childBirths = allBirths.filter((b) => b.parentDomain === domain).map((b) => {
+  const parentBirths = allBirths.filter((b) => b.parentDomain === domain);
+  const childBirths = parentBirths.map((b) => {
     const withParent = attachParentSetup(b, allBirths);
+    // BIRTHS ISOLATION: with >1 birth leg, uniquify each leg's synthesized child so the legs don't collide
+    // on one generated child workspace name (the discriminator = the birth directive id, unique per leg).
+    if (parentBirths.length > 1) {
+      const birthDir = (mod.directives as Directive<unknown>[]).find((d) => d?.id === b.birthDirectiveId);
+      const schema = birthDir?.payloadSchema as z.ZodTypeAny | undefined;
+      const disc = b.birthDirectiveId;
+      const uniq = uniquifyBirthPayload(withParent.birthPayload, disc, schema);
+      if (uniq !== withParent.birthPayload) {
+        return { ...withParent, birthPayload: uniq };
+      }
+    }
     // A GATED birth with no parent-birth authority path: seat its relation via the SAME granter/seed
     // discovery the relation-bootstrap leg uses (the law's own authority path, e.g. co2's
     // seedPlatformFounder → seedPlatformAdmin → grantCo2EstateCreator → birthEstateWorkspace).