@prisma-next/emitter 0.3.0-pr.99.5 → 0.3.0

package/test/emitter.test.ts

@@ -1,75 +1,30 @@
-import type { ContractIR } from '@prisma-next/contract/ir';
-import type {
-  GenerateContractTypesOptions,
-  TargetFamilyHook,
-  TypeRenderEntry,
-  TypesImportSpec,
-} from '@prisma-next/contract/types';
-import type { EmitOptions } from '@prisma-next/core-control-plane/emission';
-import { emit } from '@prisma-next/core-control-plane/emission';
-import { createOperationRegistry } from '@prisma-next/operations';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 import { timeouts } from '@prisma-next/test-utils';
 import { describe, expect, it } from 'vitest';
-import { createContractIR } from './utils';
-
-const mockSqlHook: TargetFamilyHook = {
-  id: 'sql',
-  validateTypes: (ir: ContractIR) => {
-    const storage = ir.storage as
-      | { tables?: Record<string, { columns?: Record<string, { codecId?: string }> }> }
-      | undefined;
-    if (!storage?.tables) {
-      return;
-    }
-
-    // Only validate codec ID format (ns/name@version)
-    // Namespace validation removed - codecs can use any namespace
-    const typeIdRegex = /^([^/]+)\/([^@]+)@(\d+)$/;
-
-    for (const [tableName, table] of Object.entries(storage.tables)) {
-      if (!table.columns) continue;
-      for (const [colName, col] of Object.entries(table.columns)) {
-        if (!col.codecId) {
-          throw new Error(`Column "${colName}" in table "${tableName}" is missing codecId`);
-        }
-
-        if (!typeIdRegex.test(col.codecId)) {
-          throw new Error(
-            `Column "${colName}" in table "${tableName}" has invalid codecId format "${col.codecId}". Expected format: ns/name@version`,
-          );
-        }
-      }
-    }
-  },
-  validateStructure: (ir: ContractIR) => {
-    if (ir.targetFamily !== 'sql') {
-      throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
-    }
-  },
-  generateContractTypes: (ir: ContractIR, _codecTypeImports, _operationTypeImports) => {
-    // Access ir properties to satisfy lint rules, but we don't use them in the mock
-    void ir;
-    void _codecTypeImports;
-    void _operationTypeImports;
-    return `// Generated contract types
-export type CodecTypes = Record<string, never>;
-export type LaneCodecTypes = CodecTypes;
-export type Contract = unknown;
-`;
-  },
-};
+import type { EmitStackInput } from '../src/exports';
+import { emit } from '../src/exports';
+import { createMockSpi } from './mock-spi';
+import { createTestContract } from './utils';
+
+const mockSqlHook = createMockSpi();
 
 describe('emitter', () => {
   it(
     'emits contract.json and contract.d.ts',
     async () => {
-      const ir = createContractIR({
+      const ir = createTestContract({
         models: {
           User: {
-            storage: { table: 'user' },
+            storage: {
+              table: 'user',
+              fields: {
+                id: { column: 'id' },
+                email: { column: 'email' },
+              },
+            },
             fields: {
-              id: { column: 'id' },
-              email: { column: 'email' },
+              id: { type: { kind: 'scalar', codecId: 'pg/int4@1' }, nullable: false },
+              email: { type: { kind: 'scalar', codecId: 'pg/text@1' }, nullable: false },
             },
             relations: {},
           },
@@ -96,21 +51,17 @@ describe('emitter', () => {
         },
       });
 
-      // Create empty registry and minimal test data (emitter tests don't load packs)
-      const operationRegistry = createOperationRegistry();
       const codecTypeImports: TypesImportSpec[] = [];
       const operationTypeImports: TypesImportSpec[] = [];
       const extensionIds = ['postgres', 'pg'];
-      const options: EmitOptions = {
-        outputDir: '',
-        operationRegistry,
+      const options: EmitStackInput = {
         codecTypeImports,
         operationTypeImports,
         extensionIds,
       };
 
       const result = await emit(ir, options, mockSqlHook);
-      expect(result.coreHash).toMatch(/^sha256:[a-f0-9]{64}$/);
+      expect(result.storageHash).toMatch(/^sha256:[a-f0-9]{64}$/);
       expect(result.contractDts).toContain('export type Contract');
       expect(result.contractDts).toContain('CodecTypes');
 
@@ -122,16 +73,14 @@ describe('emitter', () => {
     timeouts.typeScriptCompilation,
   );
 
-  it('does not validate codec namespaces against extensions', async () => {
-    // Namespace validation removed - codecs can use any namespace
-    const ir = createContractIR({
+  it('emits contract even when extension pack namespace does not match extensionIds', async () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
             columns: {
-              id: { codecId: 'unknown/type@1', nativeType: 'unknown_type', nullable: false },
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
             },
-            primaryKey: { columns: ['id'] },
             uniques: [],
             indexes: [],
             foreignKeys: [],
@@ -140,30 +89,26 @@ describe('emitter', () => {
       },
     });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    // Should succeed - namespace validation removed
     const result = await emit(ir, options, mockSqlHook);
     expect(result.contractJson).toBeDefined();
     expect(result.contractDts).toBeDefined();
   });
 
-  it('validates type ID format', async () => {
-    const ir = createContractIR({
+  it('tolerates codec namespaces not registered in extensionIds', async () => {
+    const ir = createTestContract({
       storage: {
         tables: {
-          user: {
+          data: {
             columns: {
-              id: { codecId: 'invalid-format', nativeType: 'int4', nullable: false },
+              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              value: { codecId: 'unknown/type@1', nativeType: 'custom', nullable: false },
             },
-            primaryKey: { columns: ['id'] },
             uniques: [],
             indexes: [],
             foreignKeys: [],
@@ -172,21 +117,19 @@ describe('emitter', () => {
       },
     });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
-      extensionIds: [],
+      extensionIds: ['some-other-extension'],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('invalid codecId format');
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractJson).toBeDefined();
+    expect(result.contractDts).toBeDefined();
   });
 
-  it('throws error when targetFamily is missing', async () => {
-    const ir = createContractIR({
-      targetFamily: undefined as unknown as string,
+  it('handles missing extensionPacks field', async () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -199,25 +142,21 @@ describe('emitter', () => {
           },
         },
       },
-    }) as ContractIR;
+    });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have targetFamily',
-    );
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractJson).toBeDefined();
+    expect(result.contractDts).toBeDefined();
   });
 
-  it('throws error when target is missing', async () => {
-    const ir = createContractIR({
-      target: undefined as unknown as string,
+  it('handles empty packs array', async () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
@@ -230,474 +169,164 @@ describe('emitter', () => {
           },
         },
       },
-    }) as ContractIR;
+    });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have target');
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractJson).toBeDefined();
+    expect(result.contractDts).toBeDefined();
   });
 
-  it('emits contract even when extension pack namespace does not match extensionIds', async () => {
-    // Adapter-provided codecs (pg/int4@1) don't need to be in contract.extensionPacks
-    const ir = createContractIR({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
+  it('omits sources from emitted contract artifact', async () => {
+    const ir = createTestContract({
+      sources: {
+        schema: { sourceId: 'schema.prisma' },
       },
     });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
-      extensionIds: [], // No extensions, but codec still works
+      extensionIds: [],
     };
 
-    // Should succeed - adapter-provided codecs don't need to be in contract.extensionPacks
     const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
+    const contractJson = JSON.parse(result.contractJson) as Record<string, unknown>;
+    expect(contractJson).not.toHaveProperty('sources');
   });
 
-  it('handles missing extensionPacks field', async () => {
-    // Namespace validation removed - codecs can use any namespace
-    const ir = createContractIR({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-            },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
-          },
-        },
+  it('accepts meta keys when family validation allows them', async () => {
+    const ir = createTestContract({
+      meta: {
+        sourceId: 'schema.prisma',
+        schemaPath: '/tmp/schema.prisma',
+        source: 'psl',
       },
     });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    // Should succeed - namespace validation removed
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
   });
 
-  it('handles empty packs array', async () => {
-    // Namespace validation removed - codecs can use any namespace
-    const ir = createContractIR({
+  it('accepts canonical section keys when family validation allows them', async () => {
+    const ir = createTestContract({
       storage: {
         tables: {
           user: {
             columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+              id: {
+                codecId: 'pg/int4@1',
+                nativeType: 'int4',
+                nullable: false,
+                sourceId: 'schema.prisma',
+              },
             },
+            primaryKey: { columns: ['id'] },
             uniques: [],
             indexes: [],
             foreignKeys: [],
           },
         },
-      },
+      } as unknown as Record<string, unknown>,
     });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    // Should succeed - namespace validation removed
-    const result = await emit(ir, options, mockSqlHook);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
-  });
-
-  it('throws error when schemaVersion is missing', async () => {
-    const ir = createContractIR({
-      schemaVersion: undefined as unknown as string,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have schemaVersion',
-    );
-  });
-
-  it('throws error when models is missing', async () => {
-    const ir = createContractIR({
-      models: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have models');
-  });
-
-  it('throws error when models is not an object', async () => {
-    const ir = createContractIR({
-      models: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have models');
-  });
-
-  it('throws error when storage is missing', async () => {
-    const ir = createContractIR({
-      storage: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have storage');
-  });
-
-  it('throws error when storage is not an object', async () => {
-    const ir = createContractIR({
-      storage: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have storage');
-  });
-
-  it('throws error when relations is missing', async () => {
-    const ir = createContractIR({
-      relations: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have relations');
-  });
-
-  it('throws error when relations is not an object', async () => {
-    const ir = createContractIR({
-      relations: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have relations');
-  });
-
-  it('throws error when extension packs are missing', async () => {
-    const ir = createContractIR({
-      extensionPacks: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have extensionPacks',
-    );
-  });
-
-  it('throws error when extension packs are not an object', async () => {
-    const ir = createContractIR({
-      extensionPacks: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have extensionPacks',
-    );
-  });
-
-  it('throws error when capabilities is missing', async () => {
-    const ir = createContractIR({
-      capabilities: undefined as unknown as Record<string, Record<string, boolean>>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have capabilities',
-    );
-  });
-
-  it('throws error when capabilities is not an object', async () => {
-    const ir = createContractIR({
-      capabilities: 'not-an-object' as unknown as Record<string, Record<string, boolean>>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow(
-      'ContractIR must have capabilities',
-    );
-  });
-
-  it('throws error when meta is missing', async () => {
-    const ir = createContractIR({
-      meta: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have meta');
+    await expect(emit(ir, options, mockSqlHook)).resolves.toMatchObject({
+      contractJson: expect.any(String),
+      contractDts: expect.any(String),
+    });
   });
 
-  it('throws error when meta is not an object', async () => {
-    const ir = createContractIR({
-      meta: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
-
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
-      extensionIds: [],
-    };
-
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have meta');
-  });
+  it('emits contract even when extensionIds are not in contract.extensionPacks', async () => {
+    const ir = createTestContract({
+      storage: {
+        tables: {},
+      },
+    });
 
-  it('throws error when sources is missing', async () => {
-    const ir = createContractIR({
-      sources: undefined as unknown as Record<string, unknown>,
-    }) as ContractIR;
+    const mockHookNoTypeValidation = createMockSpi();
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
-      extensionIds: [],
+      extensionIds: ['postgres'],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    const result = await emit(ir, options, mockHookNoTypeValidation);
+    expect(result.contractJson).toBeDefined();
+    expect(result.contractDts).toBeDefined();
   });
 
-  it('throws error when sources is not an object', async () => {
-    const ir = createContractIR({
-      sources: 'not-an-object' as unknown as Record<string, unknown>,
-    }) as ContractIR;
+  it('defaults codecTypeImports and operationTypeImports to empty arrays when omitted', async () => {
+    const ir = createTestContract({
+      storage: { tables: {} },
+    });
 
-    const operationRegistry = createOperationRegistry();
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry,
-      codecTypeImports: [],
-      operationTypeImports: [],
+    const options: EmitStackInput = {
       extensionIds: [],
     };
 
-    await expect(emit(ir, options, mockSqlHook)).rejects.toThrow('ContractIR must have sources');
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractDts).toContain('export type CodecTypes');
+    expect(result.contractDts).toContain('export type OperationTypes');
   });
 
-  it('emits contract even when extensionIds are not in contract.extensionPacks', async () => {
-    // extensionIds includes adapters/targets which are not in contract.extensionPacks
-    const ir = createContractIR({
-      storage: {
-        tables: {},
-      },
+  it('passes parameterizedTypeImports and queryOperationTypeImports to generateContractDts', async () => {
+    const ir = createTestContract({
+      storage: { tables: {} },
     });
 
-    // Use a mock hook that doesn't validate types to avoid type validation errors
-    const mockHookNoTypeValidation: TargetFamilyHook = {
-      id: 'sql',
-      validateTypes: () => {
-        // Skip type validation
-      },
-      validateStructure: (ir: ContractIR) => {
-        if (ir.targetFamily !== 'sql') {
-          throw new Error(`Expected targetFamily "sql", got "${ir.targetFamily}"`);
-        }
-      },
-      generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports) => {
-        void _codecTypeImports;
-        void _operationTypeImports;
-        return `// Generated contract types
-export type CodecTypes = Record<string, never>;
-export type LaneCodecTypes = CodecTypes;
-export type Contract = unknown;
-`;
-      },
-    };
+    const queryOperationTypeImports: TypesImportSpec[] = [
+      { package: '@ext/query', named: 'QueryOperationTypes', alias: 'ExtQueryOpTypes' },
+    ];
 
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry: createOperationRegistry(),
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
-      extensionIds: ['postgres'], // Adapter ID, not an extension
+      extensionIds: [],
+      queryOperationTypeImports,
     };
 
-    // Should succeed - extensionIds can include adapters/targets
-    const result = await emit(ir, options, mockHookNoTypeValidation);
-    expect(result.contractJson).toBeDefined();
-    expect(result.contractDts).toBeDefined();
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractDts).toContain("from '@ext/query'");
   });
 
-  it('passes parameterizedRenderers to generateContractTypes options', async () => {
-    const ir = createContractIR({
-      storage: {
-        tables: {},
+  it('emits execution clause when contract has execution section', async () => {
+    const ir = createTestContract({
+      storage: { tables: {} },
+      execution: {
+        executionHash: 'sha256:abc123',
+        operations: {},
       },
     });
 
-    let receivedOptions: GenerateContractTypesOptions | undefined;
-
-    const mockHookCapturingOptions: TargetFamilyHook = {
-      id: 'sql',
-      validateTypes: () => {},
-      validateStructure: () => {},
-      generateContractTypes: (_ir, _codecTypeImports, _operationTypeImports, options) => {
-        receivedOptions = options;
-        return `// Generated contract types
-export type CodecTypes = Record<string, never>;
-export type LaneCodecTypes = CodecTypes;
-export type Contract = unknown;
-`;
-      },
-    };
-
-    const vectorRenderer: TypeRenderEntry = {
-      codecId: 'pg/vector@1',
-      render: (params) => `Vector<${params['length']}>`,
-    };
-
-    const parameterizedRenderers = new Map<string, TypeRenderEntry>();
-    parameterizedRenderers.set('pg/vector@1', vectorRenderer);
-
-    const options: EmitOptions = {
-      outputDir: '',
-      operationRegistry: createOperationRegistry(),
+    const options: EmitStackInput = {
       codecTypeImports: [],
       operationTypeImports: [],
       extensionIds: [],
-      parameterizedRenderers,
     };
 
-    await emit(ir, options, mockHookCapturingOptions);
-
-    expect(receivedOptions).toBeDefined();
-    expect(receivedOptions?.parameterizedRenderers).toBeDefined();
-    expect(receivedOptions?.parameterizedRenderers?.size).toBe(1);
-
-    const entry = receivedOptions?.parameterizedRenderers?.get('pg/vector@1');
-    expect(entry).toBeDefined();
-    expect(entry?.codecId).toBe('pg/vector@1');
-    expect(entry?.render({ length: 1536 }, { codecTypesName: 'CodecTypes' })).toBe('Vector<1536>');
+    const result = await emit(ir, options, mockSqlHook);
+    expect(result.contractDts).toContain('readonly execution:');
+    expect(result.contractDts).toContain('readonly executionHash: ExecutionHash');
+    expect(result.executionHash).toMatch(/^sha256:[a-f0-9]{64}$/);
   });
 });