@prisma-next/emitter 0.3.0-dev.135 → 0.3.0-dev.146

package/dist/test/utils.d.mts

@@ -1,19 +1,21 @@
-import { ContractIR } from "@prisma-next/contract/ir";
+import { Contract } from "@prisma-next/contract/types";
 
 //#region test/utils.d.ts
-
-/**
- * Factory function for creating ContractIR objects in tests.
- * Provides sensible defaults and allows overriding specific fields.
- * Uses the emitter factories internally for consistency.
- *
- * If a field is explicitly set to `undefined` in overrides, it will be omitted
- * from the result (useful for testing validation of missing fields).
- */
-declare function createContractIR(overrides?: Partial<ContractIR> & {
+type TestContractOverrides = {
+  target?: string;
+  targetFamily?: string;
+  roots?: Record<string, string>;
+  models?: Record<string, unknown>;
+  storage?: Record<string, unknown>;
+  capabilities?: Record<string, Record<string, boolean>>;
+  extensionPacks?: Record<string, unknown>;
+  execution?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
   storageHash?: string;
-  profileHash?: string;
-}): ContractIR;
+  schemaVersion?: string;
+  sources?: Record<string, unknown>;
+};
+declare function createTestContract(overrides?: TestContractOverrides): Contract;
 //#endregion
-export { createContractIR };
+export { createTestContract };
 //# sourceMappingURL=utils.d.mts.map

package/dist/test/utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;;;;;;iBAAgB,gBAAA,aACH,QAAQ;;;IAClB"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"sourcesContent":[],"mappings":";;;KAGK,qBAAA;;EAAA,YAAA,CAAA,EAAA,MAAA;EAGK,KAAA,CAAA,EAAA,MAAA,CAAA,MAAA,EAAA,MAAA,CAAA;EACC,MAAA,CAAA,EAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA;EACC,OAAA,CAAA,EAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA;EACoB,YAAA,CAAA,EAAf,MAAe,CAAA,MAAA,EAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA,CAAA;EAAf,cAAA,CAAA,EACE,MADF,CAAA,MAAA,EAAA,OAAA,CAAA;EACE,SAAA,CAAA,EACL,MADK,CAAA,MAAA,EAAA,OAAA,CAAA;EACL,IAAA,CAAA,EACL,MADK,CAAA,MAAA,EAAA,OAAA,CAAA;EACL,WAAA,CAAA,EAAA,MAAA;EAGG,aAAA,CAAA,EAAA,MAAA;EAAM,OAAA,CAAA,EAAN,MAAM,CAAA,MAAA,EAAA,OAAA,CAAA;AAGlB,CAAA;iBAAgB,kBAAA,aAA8B,wBAA6B"}

package/dist/test/utils.mjs

@@ -1,57 +1,18 @@
-import { irHeader, irMeta } from "@prisma-next/contract/ir";
+import { createContract } from "@prisma-next/contract/testing";
 
 //#region test/utils.ts
-/**
-* Factory function for creating ContractIR objects in tests.
-* Provides sensible defaults and allows overriding specific fields.
-* Uses the emitter factories internally for consistency.
-*
-* If a field is explicitly set to `undefined` in overrides, it will be omitted
-* from the result (useful for testing validation of missing fields).
-*/
-function createContractIR(overrides = {}) {
-	const hasTarget = "target" in overrides;
-	const hasTargetFamily = "targetFamily" in overrides;
-	const hasStorageHash = "storageHash" in overrides;
-	const hasSchemaVersion = "schemaVersion" in overrides;
-	const hasModels = "models" in overrides;
-	const hasStorage = "storage" in overrides;
-	const hasCapabilities = "capabilities" in overrides;
-	const hasExtensionPacks = "extensionPacks" in overrides;
-	const hasMeta = "meta" in overrides;
-	const hasSources = "sources" in overrides;
-	const headerOpts = {};
-	if (hasTarget && overrides.target !== void 0) headerOpts.target = overrides.target;
-	else if (!hasTarget) headerOpts.target = "postgres";
-	if (hasTargetFamily && overrides.targetFamily !== void 0) headerOpts.targetFamily = overrides.targetFamily;
-	else if (!hasTargetFamily) headerOpts.targetFamily = "sql";
-	if (hasStorageHash && overrides.storageHash !== void 0) headerOpts.storageHash = overrides.storageHash;
-	else if (!hasStorageHash) headerOpts.storageHash = "sha256:test";
-	if (overrides.profileHash !== void 0) headerOpts.profileHash = overrides.profileHash;
-	const header = irHeader(headerOpts);
-	const metaOpts = {};
-	if (hasCapabilities && overrides.capabilities !== void 0) metaOpts.capabilities = overrides.capabilities;
-	else if (!hasCapabilities) metaOpts.capabilities = {};
-	if (hasExtensionPacks && overrides.extensionPacks !== void 0) metaOpts.extensionPacks = overrides.extensionPacks;
-	else if (!hasExtensionPacks) metaOpts.extensionPacks = {};
-	if (hasMeta && overrides.meta !== void 0) metaOpts.meta = overrides.meta;
-	else if (!hasMeta) metaOpts.meta = {};
-	if (hasSources && overrides.sources !== void 0) metaOpts.sources = overrides.sources;
-	else if (!hasSources) metaOpts.sources = {};
-	const meta = irMeta(Object.keys(metaOpts).length > 0 ? metaOpts : void 0);
-	return {
-		schemaVersion: hasSchemaVersion && overrides.schemaVersion !== void 0 ? overrides.schemaVersion : hasSchemaVersion && overrides.schemaVersion === void 0 ? void 0 : header.schemaVersion,
-		target: header.target,
-		targetFamily: header.targetFamily,
-		capabilities: hasCapabilities && overrides.capabilities === void 0 ? void 0 : !hasCapabilities || overrides.capabilities !== void 0 ? meta.capabilities : {},
-		extensionPacks: hasExtensionPacks && overrides.extensionPacks === void 0 ? void 0 : !hasExtensionPacks || overrides.extensionPacks !== void 0 ? meta.extensionPacks : {},
-		meta: hasMeta && overrides.meta === void 0 ? void 0 : !hasMeta || overrides.meta !== void 0 ? meta.meta : {},
-		sources: hasSources && overrides.sources === void 0 ? void 0 : !hasSources || overrides.sources !== void 0 ? meta.sources : {},
-		storage: hasStorage && overrides.storage === void 0 ? void 0 : hasStorage && overrides.storage !== void 0 ? overrides.storage : !hasStorage ? { tables: {} } : {},
-		models: hasModels && overrides.models === void 0 ? void 0 : hasModels && overrides.models !== void 0 ? overrides.models : !hasModels ? {} : {}
-	};
+function createTestContract(overrides = {}) {
+	const { storageHash: _sh, schemaVersion: _sv, sources: _src, storage, ...rest } = overrides;
+	const cleanStorage = storage ? (() => {
+		const { storageHash: _innerSh, ...storageRest } = storage;
+		return storageRest;
+	})() : void 0;
+	return createContract({
+		...rest,
+		...cleanStorage ? { storage: cleanStorage } : {}
+	});
 }
 
 //#endregion
-export { createContractIR };
+export { createTestContract };
 //# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":["headerOpts: {\n    target?: string;\n    targetFamily?: string;\n    storageHash?: string;\n    profileHash?: string;\n  }","metaOpts: {\n    capabilities?: Record<string, Record<string, boolean>>;\n    extensionPacks?: Record<string, unknown>;\n    meta?: Record<string, unknown>;\n    sources?: Record<string, unknown>;\n  }"],"sources":["../../test/utils.ts"],"sourcesContent":["import { type ContractIR, irHeader, irMeta } from '@prisma-next/contract/ir';\n\n/**\n * Factory function for creating ContractIR objects in tests.\n * Provides sensible defaults and allows overriding specific fields.\n * Uses the emitter factories internally for consistency.\n *\n * If a field is explicitly set to `undefined` in overrides, it will be omitted\n * from the result (useful for testing validation of missing fields).\n */\nexport function createContractIR(\n  overrides: Partial<ContractIR> & { storageHash?: string; profileHash?: string } = {},\n): ContractIR {\n  // Check if fields are explicitly undefined (not just missing)\n  const hasTarget = 'target' in overrides;\n  const hasTargetFamily = 'targetFamily' in overrides;\n  const hasStorageHash = 'storageHash' in overrides;\n  const hasSchemaVersion = 'schemaVersion' in overrides;\n  const hasModels = 'models' in overrides;\n  const hasStorage = 'storage' in overrides;\n  const hasCapabilities = 'capabilities' in overrides;\n  const hasExtensionPacks = 'extensionPacks' in overrides;\n  const hasMeta = 'meta' in overrides;\n  const hasSources = 'sources' in overrides;\n\n  // Build header, omitting fields that are explicitly undefined\n  const headerOpts: {\n    target?: string;\n    targetFamily?: string;\n    storageHash?: string;\n    profileHash?: string;\n  } = {};\n\n  if (hasTarget && overrides.target !== undefined) {\n    headerOpts.target = overrides.target;\n  } else if (!hasTarget) {\n    headerOpts.target = 'postgres';\n  }\n\n  if (hasTargetFamily && overrides.targetFamily !== undefined) {\n    headerOpts.targetFamily = overrides.targetFamily;\n  } else if (!hasTargetFamily) {\n    headerOpts.targetFamily = 'sql';\n  }\n\n  if (hasStorageHash && overrides.storageHash !== undefined) {\n    headerOpts.storageHash = overrides.storageHash;\n  } else if (!hasStorageHash) {\n    headerOpts.storageHash = 'sha256:test';\n  }\n\n  // profileHash is not part of ContractIR, but we can accept it for header creation\n  if (overrides.profileHash !== undefined) {\n    headerOpts.profileHash = overrides.profileHash;\n  }\n\n  const header = irHeader(\n    headerOpts as {\n      target: string;\n      targetFamily: string;\n      storageHash: string;\n      profileHash?: string;\n    },\n  );\n\n  // Build meta, handling explicitly undefined fields\n  // If a field is explicitly undefined, we'll omit it from the result later\n  const metaOpts: {\n    capabilities?: Record<string, Record<string, boolean>>;\n    extensionPacks?: Record<string, unknown>;\n    meta?: Record<string, unknown>;\n    sources?: Record<string, unknown>;\n  } = {};\n\n  if (hasCapabilities && overrides.capabilities !== undefined) {\n    metaOpts.capabilities = overrides.capabilities;\n  } else if (!hasCapabilities) {\n    metaOpts.capabilities = {};\n  }\n\n  if (hasExtensionPacks && overrides.extensionPacks !== undefined) {\n    metaOpts.extensionPacks = overrides.extensionPacks;\n  } else if (!hasExtensionPacks) {\n    metaOpts.extensionPacks = {};\n  }\n\n  if (hasMeta && overrides.meta !== undefined) {\n    metaOpts.meta = overrides.meta;\n  } else if (!hasMeta) {\n    metaOpts.meta = {};\n  }\n\n  if (hasSources && overrides.sources !== undefined) {\n    metaOpts.sources = overrides.sources;\n  } else if (!hasSources) {\n    metaOpts.sources = {};\n  }\n\n  const meta = irMeta(Object.keys(metaOpts).length > 0 ? metaOpts : undefined);\n\n  // Build result by constructing the object directly (ContractIR doesn't include storageHash/profileHash)\n  // When fields are explicitly undefined, include them as undefined (tests use type assertions to bypass TS)\n  const result = {\n    schemaVersion:\n      hasSchemaVersion && overrides.schemaVersion !== undefined\n        ? overrides.schemaVersion\n        : hasSchemaVersion && overrides.schemaVersion === undefined\n          ? (undefined as unknown as string)\n          : header.schemaVersion,\n    target: header.target,\n    targetFamily: header.targetFamily,\n    // Only include meta fields if they're not explicitly undefined\n    capabilities:\n      hasCapabilities && overrides.capabilities === undefined\n        ? (undefined as unknown as Record<string, Record<string, boolean>>)\n        : !hasCapabilities || overrides.capabilities !== undefined\n          ? meta.capabilities\n          : ({} as Record<string, Record<string, boolean>>),\n    extensionPacks:\n      hasExtensionPacks && overrides.extensionPacks === undefined\n        ? (undefined as unknown as Record<string, unknown>)\n        : !hasExtensionPacks || overrides.extensionPacks !== undefined\n          ? meta.extensionPacks\n          : ({} as Record<string, unknown>),\n    meta:\n      hasMeta && overrides.meta === undefined\n        ? (undefined as unknown as Record<string, unknown>)\n        : !hasMeta || overrides.meta !== undefined\n          ? meta.meta\n          : ({} as Record<string, unknown>),\n    sources:\n      hasSources && overrides.sources === undefined\n        ? (undefined as unknown as Record<string, unknown>)\n        : !hasSources || overrides.sources !== undefined\n          ? meta.sources\n          : ({} as Record<string, unknown>),\n    // Only include family sections if they're not explicitly undefined\n    storage:\n      hasStorage && overrides.storage === undefined\n        ? (undefined as unknown as Record<string, unknown>)\n        : hasStorage && overrides.storage !== undefined\n          ? (overrides.storage as Record<string, unknown>)\n          : !hasStorage\n            ? ({ tables: {} } as Record<string, unknown>)\n            : ({} as Record<string, unknown>),\n    models:\n      hasModels && overrides.models === undefined\n        ? (undefined as unknown as Record<string, unknown>)\n        : hasModels && overrides.models !== undefined\n          ? (overrides.models as Record<string, unknown>)\n          : !hasModels\n            ? {}\n            : ({} as Record<string, unknown>),\n  } as ContractIR;\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;AAUA,SAAgB,iBACd,YAAkF,EAAE,EACxE;CAEZ,MAAM,YAAY,YAAY;CAC9B,MAAM,kBAAkB,kBAAkB;CAC1C,MAAM,iBAAiB,iBAAiB;CACxC,MAAM,mBAAmB,mBAAmB;CAC5C,MAAM,YAAY,YAAY;CAC9B,MAAM,aAAa,aAAa;CAChC,MAAM,kBAAkB,kBAAkB;CAC1C,MAAM,oBAAoB,oBAAoB;CAC9C,MAAM,UAAU,UAAU;CAC1B,MAAM,aAAa,aAAa;CAGhC,MAAMA,aAKF,EAAE;AAEN,KAAI,aAAa,UAAU,WAAW,OACpC,YAAW,SAAS,UAAU;UACrB,CAAC,UACV,YAAW,SAAS;AAGtB,KAAI,mBAAmB,UAAU,iBAAiB,OAChD,YAAW,eAAe,UAAU;UAC3B,CAAC,gBACV,YAAW,eAAe;AAG5B,KAAI,kBAAkB,UAAU,gBAAgB,OAC9C,YAAW,cAAc,UAAU;UAC1B,CAAC,eACV,YAAW,cAAc;AAI3B,KAAI,UAAU,gBAAgB,OAC5B,YAAW,cAAc,UAAU;CAGrC,MAAM,SAAS,SACb,WAMD;CAID,MAAMC,WAKF,EAAE;AAEN,KAAI,mBAAmB,UAAU,iBAAiB,OAChD,UAAS,eAAe,UAAU;UACzB,CAAC,gBACV,UAAS,eAAe,EAAE;AAG5B,KAAI,qBAAqB,UAAU,mBAAmB,OACpD,UAAS,iBAAiB,UAAU;UAC3B,CAAC,kBACV,UAAS,iBAAiB,EAAE;AAG9B,KAAI,WAAW,UAAU,SAAS,OAChC,UAAS,OAAO,UAAU;UACjB,CAAC,QACV,UAAS,OAAO,EAAE;AAGpB,KAAI,cAAc,UAAU,YAAY,OACtC,UAAS,UAAU,UAAU;UACpB,CAAC,WACV,UAAS,UAAU,EAAE;CAGvB,MAAM,OAAO,OAAO,OAAO,KAAK,SAAS,CAAC,SAAS,IAAI,WAAW,OAAU;AAyD5E,QArDe;EACb,eACE,oBAAoB,UAAU,kBAAkB,SAC5C,UAAU,gBACV,oBAAoB,UAAU,kBAAkB,SAC7C,SACD,OAAO;EACf,QAAQ,OAAO;EACf,cAAc,OAAO;EAErB,cACE,mBAAmB,UAAU,iBAAiB,SACzC,SACD,CAAC,mBAAmB,UAAU,iBAAiB,SAC7C,KAAK,eACJ,EAAE;EACX,gBACE,qBAAqB,UAAU,mBAAmB,SAC7C,SACD,CAAC,qBAAqB,UAAU,mBAAmB,SACjD,KAAK,iBACJ,EAAE;EACX,MACE,WAAW,UAAU,SAAS,SACzB,SACD,CAAC,WAAW,UAAU,SAAS,SAC7B,KAAK,OACJ,EAAE;EACX,SACE,cAAc,UAAU,YAAY,SAC/B,SACD,CAAC,cAAc,UAAU,YAAY,SACnC,KAAK,UACJ,EAAE;EAEX,SACE,cAAc,UAAU,YAAY,SAC/B,SACD,cAAc,UAAU,YAAY,SACjC,UAAU,UACX,CAAC,aACE,EAAE,QAAQ,EAAE,EAAE,GACd,EAAE;EACb,QACE,aAAa,UAAU,WAAW,SAC7B,SACD,aAAa,UAAU,WAAW,SAC/B,UAAU,SACX,CAAC,YACC,EAAE,GACD,EAAE;EACd"}
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../test/utils.ts"],"sourcesContent":["import { createContract } from '@prisma-next/contract/testing';\nimport type { Contract } from '@prisma-next/contract/types';\n\ntype TestContractOverrides = {\n  target?: string;\n  targetFamily?: string;\n  roots?: Record<string, string>;\n  models?: Record<string, unknown>;\n  storage?: Record<string, unknown>;\n  capabilities?: Record<string, Record<string, boolean>>;\n  extensionPacks?: Record<string, unknown>;\n  execution?: Record<string, unknown>;\n  meta?: Record<string, unknown>;\n  storageHash?: string;\n  schemaVersion?: string;\n  sources?: Record<string, unknown>;\n};\n\nexport function createTestContract(overrides: TestContractOverrides = {}): Contract {\n  const { storageHash: _sh, schemaVersion: _sv, sources: _src, storage, ...rest } = overrides;\n  const cleanStorage = storage\n    ? (() => {\n        const { storageHash: _innerSh, ...storageRest } = storage as Record<string, unknown>;\n        return storageRest;\n      })()\n    : undefined;\n  return createContract({\n    ...rest,\n    ...(cleanStorage ? { storage: cleanStorage } : {}),\n  } as Parameters<typeof createContract>[0]);\n}\n"],"mappings":";;;AAkBA,SAAgB,mBAAmB,YAAmC,EAAE,EAAY;CAClF,MAAM,EAAE,aAAa,KAAK,eAAe,KAAK,SAAS,MAAM,SAAS,GAAG,SAAS;CAClF,MAAM,eAAe,iBACV;EACL,MAAM,EAAE,aAAa,UAAU,GAAG,gBAAgB;AAClD,SAAO;KACL,GACJ;AACJ,QAAO,eAAe;EACpB,GAAG;EACH,GAAI,eAAe,EAAE,SAAS,cAAc,GAAG,EAAE;EAClD,CAAyC"}

package/dist/type-expression-safety-7_1tfJXA.mjs

@@ -0,0 +1,8 @@
+//#region src/type-expression-safety.ts
+function isSafeTypeExpression(expr) {
+	return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
+}
+
+//#endregion
+export { isSafeTypeExpression as t };
+//# sourceMappingURL=type-expression-safety-7_1tfJXA.mjs.map

package/dist/type-expression-safety-7_1tfJXA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-expression-safety-7_1tfJXA.mjs","names":[],"sources":["../src/type-expression-safety.ts"],"sourcesContent":["export function isSafeTypeExpression(expr: string): boolean {\n  return !/import\\s*\\(|require\\s*\\(|declare\\s|export\\s|eval\\s*\\(/.test(expr);\n}\n"],"mappings":";AAAA,SAAgB,qBAAqB,MAAuB;AAC1D,QAAO,CAAC,wDAAwD,KAAK,KAAK"}

package/dist/type-expression-safety.d.mts

@@ -0,0 +1,5 @@
+//#region src/type-expression-safety.d.ts
+declare function isSafeTypeExpression(expr: string): boolean;
+//#endregion
+export { isSafeTypeExpression };
+//# sourceMappingURL=type-expression-safety.d.mts.map

package/dist/type-expression-safety.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-expression-safety.d.mts","names":[],"sources":["../src/type-expression-safety.ts"],"sourcesContent":[],"mappings":";iBAAgB,oBAAA"}

package/dist/type-expression-safety.mjs

@@ -0,0 +1,3 @@
+import { t as isSafeTypeExpression } from "./type-expression-safety-7_1tfJXA.mjs";
+
+export { isSafeTypeExpression };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/emitter",
-  "version": "0.3.0-dev.135",
+  "version": "0.3.0-dev.146",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -10,18 +10,20 @@
   ],
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.3.0-dev.135",
-    "@prisma-next/core-control-plane": "0.3.0-dev.135"
+    "prettier": "^3.3.3",
+    "@prisma-next/contract": "0.3.0-dev.146",
+    "@prisma-next/operations": "0.3.0-dev.146",
+    "@prisma-next/framework-components": "0.3.0-dev.146",
+    "@prisma-next/utils": "0.3.0-dev.146"
   },
   "devDependencies": {
     "@types/node": "24.10.4",
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/operations": "0.3.0-dev.135",
-    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/test-utils": "0.0.1"
   },
   "exports": {
     ".": {
@@ -32,6 +34,10 @@
       "types": "./dist/domain-type-generation.d.mts",
       "import": "./dist/domain-type-generation.mjs"
     },
+    "./type-expression-safety": {
+      "types": "./dist/type-expression-safety.d.mts",
+      "import": "./dist/type-expression-safety.mjs"
+    },
     "./test/utils": {
       "types": "./dist/test/utils.d.mts",
       "import": "./dist/test/utils.mjs"

package/src/domain-type-generation.ts

@@ -1,4 +1,11 @@
-import type { TypesImportSpec } from '@prisma-next/contract/types';
+import type {
+  ContractField,
+  ContractModel,
+  ContractValueObject,
+} from '@prisma-next/contract/types';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
+import { isSafeTypeExpression } from './type-expression-safety';
 
 export function serializeValue(value: unknown): string {
   if (value === null) {
@@ -48,6 +55,36 @@ export function generateRootsType(roots: Record<string, string> | undefined): st
   return `{ ${entries} }`;
 }
 
+function contractFieldModifierSuffix(field: ContractField): string {
+  const many = field.many === true ? '; readonly many: true' : '';
+  const dict = field.dict === true ? '; readonly dict: true' : '';
+  return many + dict;
+}
+
+export function generateModelFieldEntry(fieldName: string, field: ContractField): string {
+  const mods = contractFieldModifierSuffix(field);
+  const { nullable, type } = field;
+  if (type.kind === 'scalar') {
+    const typeParamsSpec =
+      type.typeParams && Object.keys(type.typeParams).length > 0
+        ? `; readonly typeParams: ${serializeValue(type.typeParams)}`
+        : '';
+    return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: { readonly kind: 'scalar'; readonly codecId: ${serializeValue(type.codecId)}${typeParamsSpec} }${mods} }`;
+  }
+  if (type.kind === 'valueObject') {
+    return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: { readonly kind: 'valueObject'; readonly name: ${serializeValue(type.name)} }${mods} }`;
+  }
+  return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${nullable}; readonly type: ${serializeValue(type)}${mods} }`;
+}
+
+export function generateModelFieldsType(fields: Record<string, ContractField>): string {
+  const fieldEntries: string[] = [];
+  for (const [fieldName, field] of Object.entries(fields)) {
+    fieldEntries.push(generateModelFieldEntry(fieldName, field));
+  }
+  return fieldEntries.length > 0 ? `{ ${fieldEntries.join('; ')} }` : 'Record<string, never>';
+}
+
 export function generateModelRelationsType(relations: Record<string, unknown>): string {
   const relationEntries: string[] = [];
 
@@ -86,6 +123,45 @@ export function generateModelRelationsType(relations: Record<string, unknown>):
   return `{ ${relationEntries.join('; ')} }`;
 }
 
+export function generateModelsType(
+  models: Record<string, ContractModel>,
+  generateModelStorage: (modelName: string, model: ContractModel) => string,
+): string {
+  if (!models || Object.keys(models).length === 0) {
+    return 'Record<string, never>';
+  }
+
+  const modelTypes: string[] = [];
+  for (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {
+    const fieldsType = generateModelFieldsType(model.fields);
+    const relationsType = generateModelRelationsType(model.relations);
+    const storageType = generateModelStorage(modelName, model);
+
+    const modelParts: string[] = [
+      `readonly fields: ${fieldsType}`,
+      `readonly relations: ${relationsType}`,
+      `readonly storage: ${storageType}`,
+    ];
+
+    if (model.owner) {
+      modelParts.push(`readonly owner: ${serializeValue(model.owner)}`);
+    }
+    if (model.discriminator) {
+      modelParts.push(`readonly discriminator: ${serializeValue(model.discriminator)}`);
+    }
+    if (model.variants) {
+      modelParts.push(`readonly variants: ${serializeValue(model.variants)}`);
+    }
+    if (model.base) {
+      modelParts.push(`readonly base: ${serializeValue(model.base)}`);
+    }
+
+    modelTypes.push(`readonly ${modelName}: { ${modelParts.join('; ')} }`);
+  }
+
+  return `{ ${modelTypes.join('; ')} }`;
+}
+
 export function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[] {
   const seenKeys = new Set<string>();
   const result: TypesImportSpec[] = [];
@@ -114,6 +190,15 @@ export function generateCodecTypeIntersection(
   return aliases.join(' & ') || 'Record<string, never>';
 }
 
+export function serializeExecutionType(execution: Record<string, unknown>): string {
+  const parts: string[] = ['readonly executionHash: ExecutionHash'];
+  for (const [key, value] of Object.entries(execution)) {
+    if (key === 'executionHash') continue;
+    parts.push(`readonly ${serializeObjectKey(key)}: ${serializeValue(value)}`);
+  }
+  return `{ ${parts.join('; ')} }`;
+}
+
 export function generateHashTypeAliases(hashes: {
   readonly storageHash: string;
   readonly executionHash?: string;
@@ -129,3 +214,144 @@ export function generateHashTypeAliases(hashes: {
     `export type ProfileHash = ProfileHashBase<'${hashes.profileHash}'>;`,
   ].join('\n');
 }
+
+export function generateFieldResolvedType(field: ContractField, codecLookup?: CodecLookup): string {
+  let baseType: string;
+  const { type } = field;
+
+  switch (type.kind) {
+    case 'scalar': {
+      let resolved: string | undefined;
+      if (codecLookup && type.typeParams && Object.keys(type.typeParams).length > 0) {
+        const codec = codecLookup.get(type.codecId);
+        if (codec?.renderOutputType) {
+          const rendered = codec.renderOutputType(type.typeParams);
+          if (rendered && isSafeTypeExpression(rendered)) {
+            resolved = rendered;
+          }
+        }
+      }
+      baseType = resolved ?? `CodecTypes[${serializeValue(type.codecId)}]['output']`;
+      break;
+    }
+    case 'valueObject':
+      baseType = type.name;
+      break;
+    case 'union': {
+      const memberTypes = type.members.map((m) => {
+        if (m.kind === 'scalar') return `CodecTypes[${serializeValue(m.codecId)}]['output']`;
+        return m.name;
+      });
+      baseType = memberTypes.join(' | ');
+      break;
+    }
+    default:
+      baseType = 'unknown';
+      break;
+  }
+
+  if (field.many === true) {
+    baseType = `ReadonlyArray<${baseType}>`;
+  }
+  if (field.dict === true) {
+    baseType = `Readonly<Record<string, ${baseType}>>`;
+  }
+  if (field.nullable) {
+    baseType = `${baseType} | null`;
+  }
+
+  return baseType;
+}
+
+export function generateFieldOutputTypesMap(
+  models: Record<string, ContractModel> | undefined,
+  codecLookup?: CodecLookup,
+): string {
+  if (!models || Object.keys(models).length === 0) {
+    return 'Record<string, never>';
+  }
+
+  const modelEntries: string[] = [];
+  for (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!model) continue;
+    const fieldEntries: string[] = [];
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      const resolvedType = generateFieldResolvedType(field, codecLookup);
+      fieldEntries.push(`readonly ${serializeObjectKey(fieldName)}: ${resolvedType}`);
+    }
+    const fieldsType =
+      fieldEntries.length > 0 ? `{ ${fieldEntries.join('; ')} }` : 'Record<string, never>';
+    modelEntries.push(`readonly ${serializeObjectKey(modelName)}: ${fieldsType}`);
+  }
+
+  return `{ ${modelEntries.join('; ')} }`;
+}
+
+export function generateValueObjectType(
+  _voName: string,
+  vo: ContractValueObject,
+  _valueObjects: Record<string, ContractValueObject>,
+): string {
+  const fieldEntries: string[] = [];
+  for (const [fieldName, field] of Object.entries(vo.fields)) {
+    const tsType = generateFieldResolvedType(field);
+    fieldEntries.push(`readonly ${serializeObjectKey(fieldName)}: ${tsType}`);
+  }
+  return fieldEntries.length > 0 ? `{ ${fieldEntries.join('; ')} }` : 'Record<string, never>';
+}
+
+export function generateContractFieldDescriptor(fieldName: string, field: ContractField): string {
+  const mods: string[] = [];
+  if (field.many === true) mods.push('; readonly many: true');
+  if (field.dict === true) mods.push('; readonly dict: true');
+  const modStr = mods.join('');
+
+  const { type } = field;
+  if (type.kind === 'scalar') {
+    const typeParamsSpec =
+      type.typeParams && Object.keys(type.typeParams).length > 0
+        ? `; readonly typeParams: ${serializeValue(type.typeParams)}`
+        : '';
+    return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: { readonly kind: 'scalar'; readonly codecId: ${serializeValue(type.codecId)}${typeParamsSpec} }${modStr} }`;
+  }
+  if (type.kind === 'valueObject') {
+    return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: { readonly kind: 'valueObject'; readonly name: ${serializeValue(type.name)} }${modStr} }`;
+  }
+  return `readonly ${serializeObjectKey(fieldName)}: { readonly nullable: ${field.nullable}; readonly type: ${serializeValue(type)}${modStr} }`;
+}
+
+export function generateValueObjectsDescriptorType(
+  valueObjects: Record<string, ContractValueObject> | undefined,
+): string {
+  if (!valueObjects || Object.keys(valueObjects).length === 0) {
+    return 'Record<string, never>';
+  }
+
+  const voEntries: string[] = [];
+  for (const [voName, vo] of Object.entries(valueObjects)) {
+    const fieldEntries: string[] = [];
+    for (const [fieldName, field] of Object.entries(vo.fields)) {
+      fieldEntries.push(generateContractFieldDescriptor(fieldName, field));
+    }
+    const fieldsType =
+      fieldEntries.length > 0 ? `{ ${fieldEntries.join('; ')} }` : 'Record<string, never>';
+    voEntries.push(`readonly ${serializeObjectKey(voName)}: { readonly fields: ${fieldsType} }`);
+  }
+
+  return `{ ${voEntries.join('; ')} }`;
+}
+
+export function generateValueObjectTypeAliases(
+  valueObjects: Record<string, ContractValueObject> | undefined,
+): string {
+  if (!valueObjects || Object.keys(valueObjects).length === 0) {
+    return '';
+  }
+
+  const aliases: string[] = [];
+  for (const [voName, vo] of Object.entries(valueObjects)) {
+    const voType = generateValueObjectType(voName, vo, valueObjects);
+    aliases.push(`export type ${voName} = ${voType};`);
+  }
+  return aliases.join('\n');
+}

package/src/emit-types.ts

@@ -0,0 +1,23 @@
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
+import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
+
+/**
+ * The subset of ControlStack that emit() reads.
+ * All fields are optional so tests can pass minimal objects.
+ * A full ControlStack satisfies this via structural typing.
+ */
+export interface EmitStackInput {
+  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly operationTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds?: ReadonlyArray<string>;
+  readonly codecLookup?: CodecLookup;
+}
+
+export interface EmitResult {
+  readonly contractJson: string;
+  readonly contractDts: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}

package/src/emit.ts

@@ -0,0 +1,68 @@
+import { canonicalizeContractToObject } from '@prisma-next/contract/hashing';
+import type { Contract } from '@prisma-next/contract/types';
+import type { EmissionSpi } from '@prisma-next/framework-components/emission';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { format } from 'prettier';
+import type { EmitResult, EmitStackInput } from './emit-types';
+import { generateContractDts } from './generate-contract-dts';
+
+const SCHEMA_VERSION = '1';
+
+export async function emit(
+  contract: Contract,
+  stack: EmitStackInput,
+  targetFamily: EmissionSpi,
+): Promise<EmitResult> {
+  const { codecTypeImports, operationTypeImports, queryOperationTypeImports } = stack;
+
+  const { storageHash } = contract.storage;
+  const executionHash = contract.execution?.executionHash;
+  const { profileHash } = contract;
+
+  const canonicalized = canonicalizeContractToObject(contract, {
+    schemaVersion: SCHEMA_VERSION,
+  });
+  const contractJsonString = JSON.stringify(
+    {
+      ...canonicalized,
+      _generated: {
+        warning: '⚠️  GENERATED FILE - DO NOT EDIT',
+        message: 'This file is automatically generated by "prisma-next contract emit".',
+        regenerate: 'To regenerate, run: prisma-next contract emit',
+      },
+    },
+    null,
+    2,
+  );
+
+  const generateOptions = queryOperationTypeImports ? { queryOperationTypeImports } : undefined;
+
+  const contractTypeHashes = {
+    storageHash,
+    ...ifDefined('executionHash', executionHash),
+    profileHash,
+  };
+  const contractDtsRaw = generateContractDts(
+    contract,
+    targetFamily,
+    codecTypeImports ?? [],
+    operationTypeImports ?? [],
+    contractTypeHashes,
+    generateOptions,
+    stack.codecLookup,
+  );
+  const contractDts = await format(contractDtsRaw, {
+    parser: 'typescript',
+    singleQuote: true,
+    semi: true,
+    printWidth: 100,
+  });
+
+  return {
+    contractJson: contractJsonString,
+    contractDts,
+    storageHash,
+    ...ifDefined('executionHash', executionHash),
+    profileHash,
+  };
+}

package/src/exports/index.ts

@@ -1,15 +1,7 @@
-// Re-export types from @prisma-next/contract for backward compatibility
-export type {
-  TargetFamilyHook,
-  TypesImportSpec,
-  ValidationContext,
-} from '@prisma-next/contract/types';
-export type { EmitOptions, EmitResult } from '@prisma-next/core-control-plane/emission';
-// Re-export emit function and types from core-control-plane
-export { emit } from '@prisma-next/core-control-plane/emission';
 export {
   deduplicateImports,
   generateCodecTypeIntersection,
+  generateFieldOutputTypesMap,
   generateHashTypeAliases,
   generateImportLines,
   generateModelRelationsType,
@@ -17,3 +9,6 @@ export {
   serializeObjectKey,
   serializeValue,
 } from '../domain-type-generation';
+export { emit } from '../emit';
+export type { EmitResult, EmitStackInput } from '../emit-types';
+export { generateContractDts } from '../generate-contract-dts';