test(enums): acceptance guards + emit/no-emit agreement (TML-2952 D4)

Add the A1/A2 structural guard (enum-typing-codec-seam.guard.test.ts, modeled on
rls-layer-invariant): the deleted direct-render helpers stay gone, and the only
domain-enum typing reader repo-wide is the Mongo interim resolver. Add the A6
explicit assertion in the demo type test: the emitted Post.priority field type
equals the no-emit db.enums value union. Update the mongo enum e2e mock lookup to
supply renderValueTypeFor (mirrors production; shipped contract byte-identical).

Full CI gate set green (build/typecheck force, whole Lint job, fixtures:check
empty diff, test:packages/integration/e2e) except 3 config-loader tests that fail
only on macOS (tmpdir /var vs /private/var), untouched by and unrelated to this
slice, green on Linux CI.

Signed-off-by: willbot <w.a.madden+machine@gmail.com>
Signed-off-by: Will Madden <madden@prisma.io>

Author: wmadden-electric

examples/prisma-next-demo/test/demo-dx.types.test.ts

@@ -46,6 +46,16 @@ test('emitted contract.d.ts types Post.priority as the value union, not string',
   expectTypeOf<PriorityOutput>().not.toEqualTypeOf<string>();
 });
 
+// A6 (TML-2952): emit vs no-emit agreement. The emitted `FieldOutputTypes` enum
+// field type (produced on the emit path via the codec seam) must equal the enum's
+// authored value union carried by `db.enums` (the no-emit reference — the authored
+// member values propagated without serialization). Same enum, both paths, one union.
+test('A6: emitted Post.priority field type equals the no-emit db.enums value union', () => {
+  type EmittedPriority = FieldOutputTypes['public']['Post']['priority'];
+  type NoEmitPriorityValues = EnumValues<typeof db.enums.public.Priority>;
+  expectTypeOf<EmittedPriority>().toEqualTypeOf<NoEmitPriorityValues>();
+});
+
 test('emitted contract: db.sql.public.post SELECT priority yields the value union', () => {
   const plan = db.sql.public.post.select('id', 'priority').build();
   type Row = ResultType<typeof plan>;

packages/1-framework/3-tooling/emitter/test/enum-typing-codec-seam.guard.test.ts

@@ -0,0 +1,129 @@
+/**
+ * Structural acceptance guards for the enum-typing-via-codec slice (TML-2952).
+ *
+ * A1 — every emit-path enum/value-set type goes through the codec seam
+ *      (`CodecLookup.renderValueTypeFor` / `CodecDescriptor.renderValueType`).
+ *      The pre-refactor helpers that rendered stored values straight to TS
+ *      literals (`renderValueSetUnionBase`, `renderValueSetLiteral`,
+ *      `renderEnumValueUnion`, `renderEnumMemberLiteral`) and the
+ *      `DomainEnumLookup` indirection stay deleted, and no emit-path source
+ *      reintroduces a direct value-to-literal render.
+ *
+ * A2 — no SQL or framework-emitter source reads `domain.enum` / `ns.enum` to
+ *      PRODUCE A TYPE. The single allowed `ns.enum` read in
+ *      `generate-contract-dts.ts` feeds `generateEnumBlockType`, which emits the
+ *      runtime `db.enums` dictionary block (not a field/column type). The only
+ *      domain-enum *typing* reader repo-wide is the Mongo interim resolver
+ *      (`packages/2-mongo-family/3-tooling/emitter/src/index.ts`), removed by
+ *      TML-2953.
+ *
+ * Comments are stripped before scanning so the doc comments naming the deleted
+ * helpers (here and in the production sources) do not trip the guard.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+const repoRoot = path.resolve(__dirname, '../../../../..');
+
+function stripComments(source: string): string {
+  return source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '');
+}
+
+function collectSourceFiles(dir: string): string[] {
+  const files: string[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === 'dist' || entry.name === 'node_modules' || entry.name === 'test') continue;
+      files.push(...collectSourceFiles(full));
+    } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+
+function scan(
+  relDir: string,
+  patterns: readonly RegExp[],
+): Array<{ file: string; line: number; text: string }> {
+  const hits: Array<{ file: string; line: number; text: string }> = [];
+  for (const file of collectSourceFiles(path.join(repoRoot, relDir))) {
+    const lines = stripComments(fs.readFileSync(file, 'utf-8')).split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line === undefined) continue;
+      for (const pattern of patterns) {
+        if (pattern.test(line)) {
+          hits.push({ file: path.relative(repoRoot, file), line: i + 1, text: line.trim() });
+          break;
+        }
+      }
+    }
+  }
+  return hits;
+}
+
+// The deleted direct-render helpers and the retired domain-enum typing indirection.
+const DELETED_HELPER_PATTERNS = [
+  /\brenderValueSetUnionBase\b/,
+  /\brenderValueSetLiteral\b/,
+  /\brenderEnumValueUnion\b/,
+  /\brenderEnumMemberLiteral\b/,
+  /\bDomainEnumLookup\b/,
+  /\bdomainEnumLookup\b/,
+];
+
+// An actual read of the domain enum entity: `.enum` immediately followed by an
+// index/optional-index/close-paren (`(ns.enum)`, `.enum[…]`, `.enum?.[…]`).
+// This deliberately ignores `.enum` appearing inside a string literal (e.g. a
+// `blindCast` reason describing the cast) — only access syntax counts.
+const DOMAIN_ENUM_READ = /\.enum\s*(\?\.\[|\[|\))/;
+
+describe('A1: enum/value-set emit typing goes through the codec seam', () => {
+  it('the deleted direct-render helpers do not reappear in the framework emitter source', () => {
+    const hits = scan('packages/1-framework/3-tooling/emitter', DELETED_HELPER_PATTERNS);
+    expect(hits).toEqual([]);
+  });
+
+  it('the deleted direct-render helpers do not reappear in the SQL emit-path source', () => {
+    const hits = scan('packages/2-sql', DELETED_HELPER_PATTERNS);
+    expect(hits).toEqual([]);
+  });
+
+  it('the deleted direct-render helpers do not reappear in the Mongo emitter source', () => {
+    const hits = scan('packages/2-mongo-family/3-tooling/emitter', DELETED_HELPER_PATTERNS);
+    expect(hits).toEqual([]);
+  });
+});
+
+describe('A2: no SQL/framework-emitter source reads domain.enum to produce a type', () => {
+  it('the SQL emitter sources enum field/column types from storage, not domain.enum', () => {
+    // The SQL emitter (3-tooling) is the emit-path typing reader; it must source
+    // from the storage value set. Authoring layers legitimately build domain.enum,
+    // so the guard is scoped to the emitter package.
+    const hits = scan('packages/2-sql/3-tooling/emitter', [DOMAIN_ENUM_READ]);
+    expect(hits).toEqual([]);
+  });
+
+  it('the only ns.enum read in the framework emitter feeds the db.enums dictionary block', () => {
+    const hits = scan('packages/1-framework/3-tooling/emitter', [DOMAIN_ENUM_READ]);
+    // Exactly one allowed read: generate-contract-dts.ts → generateEnumBlockType.
+    expect(hits).toHaveLength(1);
+    expect(hits[0]?.file).toBe(
+      'packages/1-framework/3-tooling/emitter/src/generate-contract-dts.ts',
+    );
+  });
+
+  it('the only repo-wide domain-enum typing reader is the Mongo interim resolver', () => {
+    // Mongo has no storage value set yet (TML-2953), so its emitter reads
+    // domain.enum on an interim basis. This read is expected; the test pins that
+    // it is the single Mongo-emitter domain-enum read so its removal is noticed.
+    const hits = scan('packages/2-mongo-family/3-tooling/emitter', [DOMAIN_ENUM_READ]);
+    expect(hits.map((h) => h.file)).toEqual([
+      'packages/2-mongo-family/3-tooling/emitter/src/index.ts',
+    ]);
+  });
+});

packages/3-extensions/mongo/test/mongo.enum.e2e.test.ts

@@ -64,6 +64,12 @@ const codecLookup: CodecLookup = {
   targetTypesFor: (id: string) => mongoTargetTypes[id],
   metaFor: () => undefined,
   renderOutputTypeFor: () => undefined,
+  // Enum field types are produced through the codec seam (TML-2952): the emitter
+  // renders each value-set value via `renderValueTypeFor`. `mongo/string@1` is an
+  // identity codec, so it renders the encoded string straight to a quoted literal —
+  // mirroring the real `mongo/string@1` descriptor's `renderValueType`.
+  renderValueTypeFor: (id, value) =>
+    id === 'mongo/string@1' && typeof value === 'string' ? `'${value}'` : undefined,
 };
 
 // Derive the $jsonSchema validator from the contract via the production deriver.
@@ -287,6 +293,8 @@ describe('emit-then-consume: value-union narrowing through the emitted contract.
       mongoEmission,
       mongoCodecImports,
       testHashes,
+      undefined,
+      codecLookup,
     );
 
     const outputMap = dts.slice(
@@ -311,6 +319,8 @@ describe('emit-then-consume: value-union narrowing through the emitted contract.
       mongoEmission,
       mongoCodecImports,
       testHashes,
+      undefined,
+      codecLookup,
     );
 
     const outputMap = dts.slice(
@@ -329,6 +339,8 @@ describe('emit-then-consume: value-union narrowing through the emitted contract.
       mongoEmission,
       mongoCodecImports,
       testHashes,
+      undefined,
+      codecLookup,
     );
 
     const outputMap = dts.slice(
@@ -347,6 +359,8 @@ describe('emit-then-consume: value-union narrowing through the emitted contract.
       mongoEmission,
       mongoCodecImports,
       testHashes,
+      undefined,
+      codecLookup,
     );
 
     // The emitted contract.d.ts must carry the enum entity in the domain namespace