@pattern-stack/codegen 0.6.8 → 0.7.0

package/dist/src/cli/index.js

@@ -14,7 +14,7 @@ var __decorateParam = (index2, decorator) => (target, key) => decorator(target,
 // src/cli/index.ts
 import { readFileSync as readFileSync6 } from "fs";
 import { join as join11 } from "path";
-import { Builtins, Cli, Command as Command10 } from "clipanion";
+import { Builtins, Cli, Command as Command11 } from "clipanion";
 
 // src/cli/noun-module.ts
 import { Command, Option } from "clipanion";
@@ -986,13 +986,13 @@ function renderPane(pane) {
 }
 
 // src/cli/ui/hints.ts
-function renderHints(hints8) {
+function renderHints(hints9) {
   if (isJsonMode()) return;
-  if (hints8.length === 0) return;
+  if (hints9.length === 0) return;
   console.log("");
   console.log(theme.muted("  Next:"));
-  const maxCmd = Math.max(...hints8.map((h) => h.command.length));
-  for (const h of hints8) {
+  const maxCmd = Math.max(...hints9.map((h) => h.command.length));
+  for (const h of hints9) {
     const pad = " ".repeat(maxCmd - h.command.length + 2);
     console.log(`    ${theme.system(h.command)}${pad}${theme.muted(h.description)}`);
   }
@@ -1017,13 +1017,13 @@ function buildNounSummaryCommand(noun) {
         json: this.json,
         verbose: this.verbose
       });
-      const [pane, hints8] = await Promise.all([noun.summary(ctx), noun.hints(ctx)]);
+      const [pane, hints9] = await Promise.all([noun.summary(ctx), noun.hints(ctx)]);
       if (isJsonMode()) {
-        printJson({ noun: noun.name, summary: pane, hints: hints8 });
+        printJson({ noun: noun.name, summary: pane, hints: hints9 });
         return 0;
       }
       renderPane(pane);
-      renderHints(hints8);
+      renderHints(hints9);
       return 0;
     }
   }
@@ -2791,6 +2791,80 @@ function deriveUniqueConstraint(config) {
   return columns;
 }
 
+// src/schema/junction-definition.schema.ts
+import { z as z6 } from "zod";
+
+// src/patterns/library/base-junction-fields.ts
+var BaseJunctionFields = [
+  { name: "is_primary", type: "boolean" },
+  { name: "started_at", type: "timestamp" },
+  { name: "ended_at", type: "timestamp" },
+  { name: "sourced_from", type: "text" },
+  { name: "confidence", type: "numeric(5,4)" },
+  { name: "matched_at", type: "timestamp" }
+];
+var BASE_JUNCTION_FIELD_NAMES = new Set(
+  BaseJunctionFields.map((c) => c.name)
+);
+
+// src/schema/junction-definition.schema.ts
+var EntityNameSchema = z6.string().regex(/^[a-z][a-z0-9_]*$/, "Entity reference must be snake_case");
+var JunctionDefinitionSchema = z6.object({
+  /** Discriminator literal — `pattern: Junction`. */
+  pattern: z6.literal("Junction"),
+  /**
+   * Exactly two endpoint entity names. Both intra- and cross-domain
+   * pairings are accepted; entity existence is validated by the
+   * analyzer in a later leaf.
+   */
+  between: z6.tuple([EntityNameSchema, EntityNameSchema]),
+  /**
+   * Emit BaseJunctionFields temporal columns (`started_at`, `ended_at`,
+   * `matched_at`). Default true. Matches Relationship's `temporal` toggle.
+   */
+  temporal: z6.boolean().optional().default(true),
+  /**
+   * Emit BaseJunctionFields sourcing columns (`sourced_from`,
+   * `confidence`). Default true. Matches Relationship's `sourced` toggle.
+   */
+  sourced: z6.boolean().optional().default(true),
+  /**
+   * Junction-specific fields beyond `BaseJunctionFields`. Includes the
+   * per-pairing role enum (declared inline; never shared across
+   * pairings). Shape is validated downstream by the codegen layer
+   * using the existing entity FieldDefinitionSchema.
+   */
+  fields: z6.record(z6.string(), z6.any()).optional(),
+  /**
+   * Declarative queries — same syntax as entity queries. Shape is
+   * validated downstream by the codegen layer.
+   */
+  queries: z6.array(z6.any()).optional(),
+  /**
+   * Per-side opt-out for parent-service fan-out (CGP-60). When a side
+   * is `false`, the `_inject-parent-service-*` templates emit nothing
+   * on that side (and the corresponding module wiring is skipped).
+   * The junction service body is always emitted regardless. Defaults
+   * to `{ left: true, right: true }`.
+   */
+  expose_on_parent: z6.object({
+    left: z6.boolean().optional().default(true),
+    right: z6.boolean().optional().default(true)
+  }).optional().default({ left: true, right: true })
+}).strict().refine((d) => d.between[0] !== d.between[1], {
+  message: "`between` endpoints must be distinct",
+  path: ["between"]
+}).refine(
+  (d) => {
+    const fieldNames = Object.keys(d.fields ?? {});
+    return !fieldNames.some((n) => BASE_JUNCTION_FIELD_NAMES.has(n));
+  },
+  {
+    message: "`fields:` block redeclares a reserved BaseJunctionFields column (is_primary, started_at, ended_at, sourced_from, confidence, matched_at)",
+    path: ["fields"]
+  }
+);
+
 // src/utils/yaml-loader.ts
 function loadEntityFromYaml(filePath) {
   if (!existsSync6(filePath)) {
@@ -2839,8 +2913,8 @@ function loadEntityFromYaml(filePath) {
 }
 function formatZodErrors(error) {
   return error.errors.map((err) => {
-    const path29 = err.path.join(".");
-    const location = path29 ? `at '${path29}'` : "at root";
+    const path30 = err.path.join(".");
+    const location = path30 ? `at '${path30}'` : "at root";
     return `${err.message} ${location}`;
   });
 }
@@ -2934,12 +3008,58 @@ function loadEventFromYaml(filePath) {
     filePath
   };
 }
+function loadJunctionFromYaml(filePath) {
+  if (!existsSync6(filePath)) {
+    return {
+      success: false,
+      error: `File not found: ${filePath}`,
+      filePath
+    };
+  }
+  let content;
+  try {
+    content = readFileSync4(filePath, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      error: `Failed to read file: ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch (err) {
+    return {
+      success: false,
+      error: `Invalid YAML syntax in ${filePath}`,
+      details: [err instanceof Error ? err.message : String(err)],
+      filePath
+    };
+  }
+  const result = JunctionDefinitionSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      success: false,
+      error: `Validation failed for ${filePath}`,
+      details: formatZodErrors(result.error),
+      filePath
+    };
+  }
+  return {
+    success: true,
+    definition: result.data,
+    filePath
+  };
+}
 function detectYamlType(filePath) {
   if (!existsSync6(filePath)) return "unknown";
   try {
     const content = readFileSync4(filePath, "utf-8");
     const parsed = parseYaml(content);
     if (parsed && typeof parsed === "object") {
+      if (parsed.pattern === "Junction") return "junction";
       if ("entity" in parsed) return "entity";
       if ("relationship" in parsed) return "relationship";
     }
@@ -3392,19 +3512,19 @@ function findCircularDependencies(graph) {
   const cycles = [];
   const visited = /* @__PURE__ */ new Set();
   const recursionStack = /* @__PURE__ */ new Set();
-  function dfs(node, path29) {
+  function dfs(node, path30) {
     visited.add(node);
     recursionStack.add(node);
     const outgoingEdges = graph.edges.filter((e) => e.from === node);
     for (const edge of outgoingEdges) {
       if (!visited.has(edge.to)) {
-        dfs(edge.to, [...path29, edge.to]);
+        dfs(edge.to, [...path30, edge.to]);
       } else if (recursionStack.has(edge.to)) {
-        const cycleStart = path29.indexOf(edge.to);
+        const cycleStart = path30.indexOf(edge.to);
         if (cycleStart !== -1) {
-          cycles.push([...path29.slice(cycleStart), edge.to]);
+          cycles.push([...path30.slice(cycleStart), edge.to]);
         } else {
-          cycles.push([...path29, edge.to]);
+          cycles.push([...path30, edge.to]);
         }
       }
     }
@@ -4001,8 +4121,8 @@ function suggestTransitiveRelationships(graph, options) {
   for (const [entityName, entity] of graph.entities) {
     if (shouldExcludeEntity(entityName, opts)) continue;
     const paths = findTransitivePaths(graph, entityName, opts);
-    for (const path29 of paths) {
-      suggestions.push(createSuggestion(path29));
+    for (const path30 of paths) {
+      suggestions.push(createSuggestion(path30));
     }
   }
   return suggestions;
@@ -4033,7 +4153,7 @@ function findTransitivePaths(graph, sourceEntity, opts) {
   while (queue.length > 0) {
     const current = queue.shift();
     if (!current) continue;
-    const { entity, depth, path: path29, visited } = current;
+    const { entity, depth, path: path30, visited } = current;
     if (depth >= opts.maxDepth) continue;
     const currentEntity = graph.entities.get(entity);
     if (!currentEntity) continue;
@@ -4044,7 +4164,7 @@ function findTransitivePaths(graph, sourceEntity, opts) {
       if (shouldExcludeEntity(target, opts)) continue;
       if (visited.has(target)) continue;
       const newPath = [
-        ...path29,
+        ...path30,
         {
           via: entity,
           relationship: relName,
@@ -4112,15 +4232,15 @@ function generateYamlSnippet(name, target, throughPath) {
     target: ${target}
     through: "${throughPath}"`;
 }
-function createSuggestion(path29) {
-  const pathDescription = [path29.source, ...path29.hops.map((h) => h.via), path29.target].join(" -> ");
+function createSuggestion(path30) {
+  const pathDescription = [path30.source, ...path30.hops.map((h) => h.via), path30.target].join(" -> ");
   return {
     severity: "info",
     type: "transitive_suggestion",
-    entity: path29.source,
+    entity: path30.source,
     message: `Potential transitive relationship: ${pathDescription}`,
-    suggestion: `Add "${path29.suggestedName}" relationship via "${path29.throughPath}"`,
-    path: path29
+    suggestion: `Add "${path30.suggestedName}" relationship via "${path30.throughPath}"`,
+    path: path30
   };
 }
 
@@ -5277,6 +5397,16 @@ var BasePattern = definePattern({
   description: "Identity pattern \u2014 base CRUD, no extra columns or methods"
 });
 
+// src/patterns/library/junction.pattern.ts
+import { z as z7 } from "zod";
+var JunctionPatternConfigSchema = z7.object({}).strict();
+var JunctionPattern = definePattern({
+  name: "Junction",
+  description: "Explicit many-to-many junction with role + temporal + sourcing metadata",
+  columns: [...BaseJunctionFields],
+  configSchema: JunctionPatternConfigSchema
+});
+
 // src/patterns/library/knowledge.pattern.ts
 var KnowledgePattern = definePattern({
   name: "Knowledge",
@@ -5341,6 +5471,7 @@ registerLibraryPattern(SyncedPattern);
 registerLibraryPattern(ActivityPattern);
 registerLibraryPattern(KnowledgePattern);
 registerLibraryPattern(MetadataPattern);
+registerLibraryPattern(JunctionPattern);
 
 // src/index.ts
 async function analyzeDomain(entitiesDir, relationshipsOrOptions) {
@@ -5448,6 +5579,14 @@ function invokeRelationshipNew(absoluteYamlPath, cwd) {
     cwd
   });
 }
+function invokeJunctionNew(absoluteYamlPath, cwd) {
+  return invokeHygen({
+    generator: "junction",
+    action: "new",
+    args: ["--yaml", absoluteYamlPath],
+    cwd
+  });
+}
 
 // src/cli/shared/git-safety.ts
 import { execSync as execSync2 } from "child_process";
@@ -5538,6 +5677,27 @@ function collectRelationships(relationshipsDir) {
   junctions.sort((a, b) => a.name.localeCompare(b.name));
   return junctions;
 }
+function listJunctionYamls(junctionsDir) {
+  if (!fs2.existsSync(junctionsDir)) return [];
+  return fs2.readdirSync(junctionsDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => path4.join(junctionsDir, f)).filter((full) => detectYamlType(full) === "junction").sort();
+}
+function deriveJunctionName(def) {
+  return def.name ?? `${def.between[0]}_${def.between[1]}`;
+}
+function collectJunctions(junctionsDir) {
+  const files = listJunctionYamls(junctionsDir);
+  const junctions = [];
+  for (const file of files) {
+    const result = loadJunctionFromYaml(file);
+    if (!result.success) continue;
+    const def = result.definition;
+    const name = deriveJunctionName(def);
+    const plural = def.table ?? pluralize(name);
+    junctions.push({ name, plural });
+  }
+  junctions.sort((a, b) => a.name.localeCompare(b.name));
+  return junctions;
+}
 function entityFilePaths(info, architecture, backendSrc) {
   const name = info.name;
   const plural = info.plural;
@@ -5605,6 +5765,7 @@ async function regenerateBarrels(opts) {
     ctx,
     entitiesDir,
     relationshipsDir = path4.resolve(ctx.cwd, "relationships"),
+    junctionsDir = path4.resolve(ctx.cwd, "junctions"),
     generatedDir,
     architecture,
     backendSrc = resolveBackendSrc(ctx),
@@ -5613,7 +5774,8 @@ async function regenerateBarrels(opts) {
   const cwd = ctx.cwd;
   const entities = [
     ...collectEntities(entitiesDir),
-    ...collectRelationships(relationshipsDir)
+    ...collectRelationships(relationshipsDir),
+    ...collectJunctions(junctionsDir)
   ].sort((a, b) => a.name.localeCompare(b.name));
   const generatedRel = path4.relative(cwd, generatedDir) || path4.basename(generatedDir);
   const modulesRel = path4.posix.join(
@@ -12434,11 +12596,291 @@ var relationshipNoun = {
 };
 var relationship_default = relationshipNoun;
 
+// src/cli/commands/junction.ts
+import path27 from "path";
+import { Command as Command8, Option as Option8 } from "clipanion";
+function summarizeJunctionFile(filePath) {
+  const result = loadJunctionFromYaml(filePath);
+  if (!result.success) return null;
+  const def = result.definition;
+  const name = def.name ?? `${def.between[0]}_${def.between[1]}`;
+  const roleChoices = def.fields?.role?.choices;
+  const hasRole = Array.isArray(roleChoices) && roleChoices.length > 0;
+  return {
+    name,
+    left: def.between[0],
+    right: def.between[1],
+    hasRole,
+    temporal: def.temporal ?? true,
+    sourced: def.sourced ?? true,
+    file: filePath
+  };
+}
+function padRight3(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+async function summary6(ctx) {
+  const junctionDir = path27.resolve(ctx.cwd, "junctions");
+  const files = listJunctionYamls(junctionDir);
+  if (files.length === 0) {
+    return {
+      title: "junctions",
+      body: [
+        "No junction definitions found.",
+        "",
+        `Create one at ${theme.system("junctions/<name>.yaml")} to get started.`
+      ]
+    };
+  }
+  const rows = files.map(summarizeJunctionFile).filter((r) => r !== null);
+  const nameCol = Math.max(4, ...rows.map((r) => r.name.length));
+  const pairingCol = Math.max(7, ...rows.map((r) => `${r.left} \xD7 ${r.right}`.length));
+  const body = rows.map((r) => {
+    const pairing = `${r.left} \xD7 ${r.right}`;
+    const flags = [
+      r.hasRole ? "role" : "",
+      r.temporal ? "temporal" : "",
+      r.sourced ? "sourced" : ""
+    ].filter(Boolean).join(", ");
+    return `${theme.system(icons.bullet)} ${padRight3(r.name, nameCol)}  ${theme.muted(
+      padRight3(pairing, pairingCol)
+    )}  ${theme.muted(flags)}`;
+  });
+  return {
+    title: "junctions",
+    body,
+    footer: `${rows.length} junctions`
+  };
+}
+async function hints6(_ctx) {
+  return [
+    { command: "codegen junction new <file>", description: "Generate one junction" },
+    { command: "codegen junction new --all", description: "Generate all junctions" },
+    { command: "codegen junction list", description: "List junction definitions" }
+  ];
+}
+var JunctionNewCommand = class extends Command8 {
+  static paths = [["junction", "new"]];
+  static usage = Command8.Usage({
+    description: "Generate code for one or more junctions from YAML",
+    examples: [
+      ["Generate a single junction", "codegen junction new junctions/opportunity_contact.yaml"],
+      ["Generate all junctions", "codegen junction new --all"],
+      ["Preview without writing", "codegen junction new junctions/opportunity_contact.yaml --dry-run"]
+    ]
+  });
+  yaml = Option8.String({ required: false });
+  all = Option8.Boolean("--all", false);
+  dryRun = Option8.Boolean("--dry-run", false);
+  force = Option8.Boolean("--force", false);
+  json = Option8.Boolean("--json", false);
+  cwd = Option8.String("--cwd", { required: false });
+  configPath = Option8.String("--config", { required: false });
+  async execute() {
+    if (this.json) setJsonMode(true);
+    const ctx = await loadContext({
+      cwd: this.cwd,
+      configPath: this.configPath,
+      json: this.json,
+      skipDetection: true
+    });
+    if (this.all && this.yaml) {
+      printError("Pass either a YAML path or --all, not both.");
+      return 2;
+    }
+    let targets = [];
+    if (this.all) {
+      const dir = path27.resolve(ctx.cwd, "junctions");
+      targets = listJunctionYamls(dir);
+      if (targets.length === 0) {
+        printError(`No junction YAML files found in ${dir}`);
+        return 1;
+      }
+    } else if (this.yaml) {
+      targets = [path27.resolve(ctx.cwd, this.yaml)];
+    } else {
+      printError("Missing YAML path. Pass a file or --all.");
+      return 2;
+    }
+    const validated = [];
+    const invalid = [];
+    for (const file of targets) {
+      const result = loadJunctionFromYaml(file);
+      if (result.success) {
+        const def = result.definition;
+        const name = def.name ?? `${def.between[0]}_${def.between[1]}`;
+        validated.push({ file, name });
+      } else {
+        invalid.push({ file, message: result.error });
+      }
+    }
+    if (invalid.length > 0) {
+      for (const i of invalid) {
+        printError(`${path27.basename(i.file)} \u2014 ${i.message}`);
+      }
+      if (!isJsonMode()) return 1;
+    }
+    if (!this.force) {
+      const gitCheck = checkGitSafety(["src"], ctx.cwd);
+      if (gitCheck.inRepo && !gitCheck.clean) {
+        printWarning(
+          `Uncommitted changes in ${gitCheck.dirty.length} files under src/. Pass --force to overwrite.`
+        );
+        if (!isJsonMode()) return 1;
+      }
+    }
+    if (this.dryRun) {
+      if (isJsonMode()) {
+        printJson({
+          command: "junction new",
+          dryRun: true,
+          junctions: validated.map((v) => ({ name: v.name, file: v.file })),
+          totals: { planned: validated.length, invalid: invalid.length }
+        });
+      } else {
+        printInfo(`Dry run \u2014 ${validated.length} junctions would be generated:`);
+        for (const v of validated) {
+          console.log(`  ${theme.muted(icons.arrow)} ${v.name}  ${theme.muted(v.file)}`);
+        }
+      }
+      return invalid.length > 0 ? 1 : 0;
+    }
+    const succeeded = [];
+    const failed = [
+      ...invalid.map((i) => ({ name: path27.basename(i.file), file: i.file, message: i.message }))
+    ];
+    for (const v of validated) {
+      if (!isJsonMode()) {
+        printInfo(`generating ${v.name}`);
+      }
+      const res = invokeJunctionNew(v.file, ctx.cwd);
+      if (res.ok) {
+        succeeded.push(v.name);
+        if (!isJsonMode()) printSuccess(`${v.name}`);
+      } else {
+        failed.push({
+          name: v.name,
+          file: v.file,
+          message: res.stderr ?? "Hygen invocation failed"
+        });
+        if (!isJsonMode()) printError(`${v.name} \u2014 ${res.stderr ?? "failed"}`);
+      }
+    }
+    const entitiesDir = ctx.entitiesDir ?? path27.resolve(ctx.cwd, "entities");
+    const relationshipsDir = path27.resolve(ctx.cwd, "relationships");
+    const junctionsDir = path27.resolve(ctx.cwd, "junctions");
+    const generatedDir = resolveGeneratedDir(ctx);
+    const architecture = resolveArchitecture(ctx);
+    let barrelResult = null;
+    try {
+      barrelResult = await regenerateBarrels({
+        ctx,
+        entitiesDir,
+        relationshipsDir,
+        junctionsDir,
+        generatedDir,
+        architecture
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!isJsonMode()) {
+        printWarning(`barrel regeneration failed \u2014 ${msg}`);
+      }
+    }
+    if (isJsonMode()) {
+      printJson({
+        command: "junction new",
+        totals: {
+          succeeded: succeeded.length,
+          failed: failed.length
+        },
+        succeeded,
+        failed,
+        barrels: barrelResult ? {
+          modules: barrelResult.modulesBarrel,
+          schema: barrelResult.schemaBarrel,
+          entityCount: barrelResult.entityCount
+        } : null
+      });
+    } else {
+      const total = validated.length + invalid.length;
+      console.log("");
+      if (failed.length === 0) {
+        printSuccess(`${total} junctions \xB7 ${succeeded.length} succeeded`);
+      } else {
+        printWarning(
+          `${total} junctions \xB7 ${succeeded.length} succeeded \xB7 ${failed.length} failed`
+        );
+      }
+      if (barrelResult) {
+        printInfo(
+          `barrels regenerated (${barrelResult.entityCount} modules) \u2192 ${path27.relative(ctx.cwd, barrelResult.modulesBarrel)}, ${path27.relative(ctx.cwd, barrelResult.schemaBarrel)}`
+        );
+      }
+    }
+    return failed.length === 0 ? 0 : 1;
+  }
+};
+var JunctionListCommand = class extends Command8 {
+  static paths = [["junction", "list"]];
+  static usage = Command8.Usage({
+    description: "List defined junctions as a table"
+  });
+  json = Option8.Boolean("--json", false);
+  cwd = Option8.String("--cwd", { required: false });
+  configPath = Option8.String("--config", { required: false });
+  async execute() {
+    if (this.json) setJsonMode(true);
+    const ctx = await loadContext({
+      cwd: this.cwd,
+      configPath: this.configPath,
+      json: this.json,
+      skipDetection: true
+    });
+    const junctionDir = path27.resolve(ctx.cwd, "junctions");
+    const files = listJunctionYamls(junctionDir);
+    if (files.length === 0) {
+      printInfo("No junction definitions found.");
+      return 0;
+    }
+    const rows = files.map(summarizeJunctionFile).filter((r) => r !== null);
+    if (isJsonMode()) {
+      printJson({
+        command: "junction list",
+        junctions: rows
+      });
+      return 0;
+    }
+    const nameW = Math.max(4, ...rows.map((r) => r.name.length));
+    const leftW = Math.max(4, ...rows.map((r) => r.left.length));
+    const rightW = Math.max(5, ...rows.map((r) => r.right.length));
+    console.log(
+      theme.muted(
+        `${padRight3("NAME", nameW)}  ${padRight3("LEFT", leftW)}  ${padRight3("RIGHT", rightW)}  ROLE  FLAGS`
+      )
+    );
+    for (const r of rows) {
+      const flags = [r.temporal ? "T" : "", r.sourced ? "S" : ""].filter(Boolean).join(",");
+      console.log(
+        `${padRight3(r.name, nameW)}  ${padRight3(r.left, leftW)}  ${padRight3(r.right, rightW)}  ${padRight3(r.hasRole ? "yes" : "no", 4)}  ${flags}`
+      );
+    }
+    return 0;
+  }
+};
+var junctionNoun = {
+  name: "junction",
+  commandClasses: [JunctionNewCommand, JunctionListCommand],
+  summary: summary6,
+  hints: hints6
+};
+var junction_default = junctionNoun;
+
 // src/cli/commands/events.ts
 import fs16 from "fs";
-import path27 from "path";
+import path28 from "path";
 import ts2 from "typescript";
-import { Command as Command8, Option as Option8 } from "clipanion";
+import { Command as Command9, Option as Option9 } from "clipanion";
 function scanSourceFileForConsumers(sourceFile, filePath, eventType) {
   const tier2 = [];
   const tier1 = [];
@@ -12572,7 +13014,7 @@ function suggestEventTypes(target, known, limit = 3) {
   return known.map((t) => ({ t, d: levenshtein(target, t) })).sort((a, b) => a.d - b.d).slice(0, limit).map((x) => x.t);
 }
 function renderConsumerReport(result, cwd) {
-  const rel = (p) => path27.relative(cwd, p) || p;
+  const rel = (p) => path28.relative(cwd, p) || p;
   const lines = [];
   const total = result.tier3.length + result.tier2.length + result.tier1.length;
   lines.push(`Event: ${result.eventType}`);
@@ -12608,7 +13050,7 @@ function renderConsumerReport(result, cwd) {
   return lines;
 }
 function runConsumersScan(opts) {
-  const scanRoot = opts.scanRoot ?? path27.join(opts.cwd, "src");
+  const scanRoot = opts.scanRoot ?? path28.join(opts.cwd, "src");
   const handlersDir = opts.handlersDir ?? scanRoot;
   const allTriggers = scanHandlerFiles(handlersDir);
   const tier3 = allTriggers.filter((t) => t.event === opts.eventType).map((t) => ({
@@ -12618,7 +13060,7 @@ function runConsumersScan(opts) {
     sourceLine: t.sourceLine
   }));
   const tier21 = fs16.existsSync(scanRoot) ? scanDirectoryForConsumers(scanRoot, opts.eventType) : { tier2: [], tier1: [], hasEventFlowImport: false };
-  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path27.join(
+  const eventsGeneratedDir = opts.eventsGeneratedDir ?? path28.join(
     resolveSubsystemsRootFromContext(opts.cwd, opts.config),
     "events",
     "generated"
@@ -12639,15 +13081,15 @@ function runConsumersScan(opts) {
 function resolveSubsystemsRootFromContext(cwd, config) {
   const configured = config?.paths?.subsystems;
   if (typeof configured === "string" && configured.length > 0) {
-    return path27.resolve(cwd, configured);
+    return path28.resolve(cwd, configured);
   }
   const backendSrc = config?.paths?.backend_src;
   const base = typeof backendSrc === "string" && backendSrc.length > 0 ? backendSrc : "src";
-  return path27.resolve(cwd, base, "shared", "subsystems");
+  return path28.resolve(cwd, base, "shared", "subsystems");
 }
-var EventsConsumersCommand = class extends Command8 {
+var EventsConsumersCommand = class extends Command9 {
   static paths = [["events", "consumers"]];
-  static usage = Command8.Usage({
+  static usage = Command9.Usage({
     description: "List all consumers of an event across the three tiers",
     examples: [
       [
@@ -12656,10 +13098,10 @@ var EventsConsumersCommand = class extends Command8 {
       ]
     ]
   });
-  eventType = Option8.String({ required: true });
-  json = Option8.Boolean("--json", false);
-  cwd = Option8.String("--cwd", { required: false });
-  configPath = Option8.String("--config", { required: false });
+  eventType = Option9.String({ required: true });
+  json = Option9.Boolean("--json", false);
+  cwd = Option9.String("--cwd", { required: false });
+  configPath = Option9.String("--config", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
     const ctx = await loadContext({
@@ -12704,7 +13146,7 @@ var EventsConsumersCommand = class extends Command8 {
     return 0;
   }
 };
-async function summary6(_ctx) {
+async function summary7(_ctx) {
   return {
     title: "events",
     body: [
@@ -12715,7 +13157,7 @@ async function summary6(_ctx) {
     ]
   };
 }
-async function hints6(_ctx) {
+async function hints7(_ctx) {
   return [
     {
       command: "codegen events consumers <type>",
@@ -12726,14 +13168,14 @@ async function hints6(_ctx) {
 var eventsNoun = {
   name: "events",
   commandClasses: [EventsConsumersCommand],
-  summary: summary6,
-  hints: hints6
+  summary: summary7,
+  hints: hints7
 };
 var events_default = eventsNoun;
 
 // src/cli/commands/orchestration.ts
-import path28 from "path";
-import { Command as Command9, Option as Option9 } from "clipanion";
+import path29 from "path";
+import { Command as Command10, Option as Option10 } from "clipanion";
 var DEFAULT_PATTERN_GLOBS = ["src/patterns/*.pattern.ts"];
 function resolvePatternGlobs(ctx) {
   const fromConfig = ctx.config?.patterns;
@@ -12746,26 +13188,26 @@ function resolveOrchestrationOutputRoot(ctx) {
   const paths = ctx.config?.paths;
   const explicit = paths?.orchestration_src;
   if (typeof explicit === "string" && explicit.length > 0) {
-    return path28.resolve(ctx.cwd, explicit);
+    return path29.resolve(ctx.cwd, explicit);
   }
   const backendSrc = typeof paths?.backend_src === "string" && paths.backend_src.length > 0 ? paths.backend_src : "app/backend/src";
-  return path28.resolve(ctx.cwd, backendSrc, "orchestration");
+  return path29.resolve(ctx.cwd, backendSrc, "orchestration");
 }
 async function reloadRegistry(ctx) {
   _resetRegistryForTests({ includeLibrary: false });
   return loadAppPatterns(resolvePatternGlobs(ctx), ctx.cwd);
 }
-var OrchestrationGenCommand = class extends Command9 {
+var OrchestrationGenCommand = class extends Command10 {
   static paths = [["orchestration", "gen"]];
-  static usage = Command9.Usage({
+  static usage = Command10.Usage({
     description: "Emit token / providers / dispatcher / module files per orchestration pattern (ADR-032 Phase 3-2/3)."
   });
-  pattern = Option9.String("--pattern", { required: false });
-  all = Option9.Boolean("--all", false);
-  dryRun = Option9.Boolean("--dry-run", false);
-  json = Option9.Boolean("--json", false);
-  cwd = Option9.String("--cwd", { required: false });
-  configPath = Option9.String("--config", { required: false });
+  pattern = Option10.String("--pattern", { required: false });
+  all = Option10.Boolean("--all", false);
+  dryRun = Option10.Boolean("--dry-run", false);
+  json = Option10.Boolean("--json", false);
+  cwd = Option10.String("--cwd", { required: false });
+  configPath = Option10.String("--config", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
     const ctx = await loadContext({
@@ -12838,12 +13280,12 @@ var OrchestrationGenCommand = class extends Command9 {
         );
         for (const f of result.files) {
           console.log(
-            `  ${theme.muted(icons.arrow)} ${path28.relative(ctx.cwd, f.outputPath)}`
+            `  ${theme.muted(icons.arrow)} ${path29.relative(ctx.cwd, f.outputPath)}`
           );
         }
       } else {
         printSuccess(
-          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path28.relative(ctx.cwd, outputRoot)}`
+          `Emitted ${result.files.length} file(s) across ${targets.length} pattern(s) \u2192 ${path29.relative(ctx.cwd, outputRoot)}`
         );
       }
       return 0;
@@ -12856,14 +13298,14 @@ var OrchestrationGenCommand = class extends Command9 {
     }
   }
 };
-var OrchestrationListCommand = class extends Command9 {
+var OrchestrationListCommand = class extends Command10 {
   static paths = [["orchestration", "list"]];
-  static usage = Command9.Usage({
+  static usage = Command10.Usage({
     description: "List registered orchestration patterns"
   });
-  json = Option9.Boolean("--json", false);
-  cwd = Option9.String("--cwd", { required: false });
-  configPath = Option9.String("--config", { required: false });
+  json = Option10.Boolean("--json", false);
+  cwd = Option10.String("--cwd", { required: false });
+  configPath = Option10.String("--config", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
     const ctx = await loadContext({
@@ -12907,14 +13349,14 @@ var OrchestrationListCommand = class extends Command9 {
     return 0;
   }
 };
-var OrchestrationValidateCommand = class extends Command9 {
+var OrchestrationValidateCommand = class extends Command10 {
   static paths = [["orchestration", "validate"]];
-  static usage = Command9.Usage({
+  static usage = Command10.Usage({
     description: "Run the Phase 3-1 project-level orchestration validator (ADR-032)"
   });
-  json = Option9.Boolean("--json", false);
-  cwd = Option9.String("--cwd", { required: false });
-  configPath = Option9.String("--config", { required: false });
+  json = Option10.Boolean("--json", false);
+  cwd = Option10.String("--cwd", { required: false });
+  configPath = Option10.String("--config", { required: false });
   async execute() {
     if (this.json) setJsonMode(true);
     const ctx = await loadContext({
@@ -12950,7 +13392,7 @@ var OrchestrationValidateCommand = class extends Command9 {
     return errors.length === 0 && loadResult.errors.length === 0 ? 0 : 1;
   }
 };
-async function summary7(ctx) {
+async function summary8(ctx) {
   try {
     await reloadRegistry(ctx);
   } catch {
@@ -12964,7 +13406,7 @@ async function summary7(ctx) {
     ]
   };
 }
-async function hints7(_ctx) {
+async function hints8(_ctx) {
   return [
     {
       command: "codegen orchestration gen",
@@ -12987,8 +13429,8 @@ var orchestrationNoun = {
     OrchestrationListCommand,
     OrchestrationValidateCommand
   ],
-  summary: summary7,
-  hints: hints7
+  summary: summary8,
+  hints: hints8
 };
 var orchestration_default = orchestrationNoun;
 
@@ -13009,9 +13451,9 @@ function readVersion() {
     return "0.0.0";
   }
 }
-var RootSummaryCommand = class extends Command10 {
-  static paths = [Command10.Default];
-  static usage = Command10.Usage({
+var RootSummaryCommand = class extends Command11 {
+  static paths = [Command11.Default];
+  static usage = Command11.Usage({
     description: "Show project status and available noun commands"
   });
   async execute() {
@@ -13055,6 +13497,7 @@ var nouns = [
   project_default,
   dev_default,
   relationship_default,
+  junction_default,
   events_default,
   orchestration_default
 ];