test(cli): catalog-conformance asserted the duplicate-name refusal without exercising it

The test was named "composition refuses a duplicate stable name" and its body was
`expect(() => composeCatalog()).not.toThrow()`. That says the three live slices do
not collide today — a true and much weaker statement than its name. Deleting the
guard from `composeCatalog` left the whole file green, which a mutation run
confirms: with the throw disabled, 8 of 9 passed, including that assertion.

`composeCatalog` closes over the module-level `SLICES`, so the refusal was
unreachable from a test at all. The composition is now `composeSlices(slices)`
with `composeCatalog()` calling it with the live three; the guard is unchanged.

Three assertions replace the one: the live slices still compose (kept, under an
honest name), two slices registering the same name throw with BOTH package names
in the message — "there is a collision" is not actionable when three packages
write into one table — and a name registered by exactly one slice is kept, so the
guard refuses a collision rather than any repeat visit.

Re-running the same mutation now fails exactly that test and nothing else.

Note for the record: this file is not a source-text test. Its one file read is
`registry.json`, `JSON.parse`d into a typed model, and every other assertion runs
`composeCatalog` / `listCatalog` / `packageOf` / `stableNameIndex` / `factory()`.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011cQxyVuTkdPmAduLiedNEg

Author: dmealing

server/typescript/packages/cli/src/lib/catalog.ts

@@ -54,9 +54,23 @@ export function catalogPackages(): string[] {
  * another.
  */
 export function composeCatalog(): Record<string, GeneratorRegistryEntry> {
+  return composeSlices(SLICES);
+}
+
+/**
+ * The composition itself, over any slice list.
+ *
+ * Separate from {@link composeCatalog} so the REFUSAL is reachable from a test. With the
+ * live `SLICES` closed over, the only thing a test could assert is that today's three
+ * packages happen not to collide — which stays true if the check above is deleted, so
+ * the guard that makes a collision a build failure was never covered by anything.
+ */
+export function composeSlices(
+  slices: ReadonlyArray<readonly [string, Record<string, GeneratorRegistryEntry>]>,
+): Record<string, GeneratorRegistryEntry> {
   const out: Record<string, GeneratorRegistryEntry> = {};
   const from: Record<string, string> = {};
-  for (const [pkg, slice] of SLICES) {
+  for (const [pkg, slice] of slices) {
     for (const [name, entry] of Object.entries(slice)) {
       if (name in out) {
         throw new Error(

server/typescript/packages/cli/test/catalog-conformance.test.ts

@@ -14,7 +14,7 @@ import { describe, it, expect } from "bun:test";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { GENERATOR_LAYERS, stableNameIndex } from "@metaobjectsdev/codegen-ts";
-import { composeCatalog, listCatalog, packageOf, catalogPackages } from "../src/lib/catalog.js";
+import { composeCatalog, composeSlices, listCatalog, packageOf, catalogPackages } from "../src/lib/catalog.js";
 
 const PORT = "typescript" as const;
 
@@ -93,12 +93,48 @@ describe("the composed TS catalog conforms to the canonical manifest", () => {
     }
   });
 
-  it("composition refuses a duplicate stable name", () => {
-    // The live slices must not collide; the throw path is what makes that a build
-    // failure rather than last-slice-wins.
+  it("the live slices do not collide", () => {
     expect(() => composeCatalog()).not.toThrow();
   });
 
+  it("composition REFUSES a duplicate stable name, naming both packages", () => {
+    // Asserted over `composeSlices` rather than `composeCatalog`, because the latter
+    // closes over the three live slices and they do not collide. Passing it two slices
+    // that DO is the only way to reach the guard — without this, deleting the throw
+    // would leave every test in this file green while `meta gen --list` described one
+    // generator and `meta gen` ran another.
+    const catalog = composeCatalog();
+    const [name, entry] = Object.entries(catalog)[0]!;
+
+    let thrown: Error | undefined;
+    try {
+      composeSlices([
+        ["@acme/first", { [name]: entry }],
+        ["@acme/second", { [name]: entry }],
+      ]);
+    } catch (e) {
+      thrown = e as Error;
+    }
+
+    expect(thrown, "a duplicate stable name was accepted").toBeDefined();
+    // The message has to name BOTH packages — "there is a collision" is not actionable
+    // when three packages register into one table.
+    expect(thrown!.message).toContain(`"${name}"`);
+    expect(thrown!.message).toContain("@acme/first");
+    expect(thrown!.message).toContain("@acme/second");
+  });
+
+  it("composition keeps a name registered by exactly one slice", () => {
+    // The other half of the guard: it must refuse a COLLISION, not any repeat visit.
+    const catalog = composeCatalog();
+    const [name, entry] = Object.entries(catalog)[0]!;
+    const composed = composeSlices([
+      ["@acme/first", { [name]: entry }],
+      ["@acme/second", {}],
+    ]);
+    expect(Object.keys(composed)).toEqual([name]);
+  });
+
   it("listCatalog() is grouped by layer, in the declared layer order", () => {
     const seen: string[] = [];
     for (const e of listCatalog()) {