@prisma-next/emitter 0.8.0 → 0.9.0-dev.1

package/dist/domain-type-generation-DNECvEA1.d.mts

@@ -0,0 +1,44 @@
+import { ContractField, ContractModel, ContractValueObject } from "@prisma-next/contract/types";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { TypesImportSpec } from "@prisma-next/framework-components/emission";
+
+//#region src/domain-type-generation.d.ts
+declare function serializeValue(value: unknown): string;
+declare function serializeObjectKey(key: string): string;
+declare function generateRootsType(roots: Record<string, string> | undefined): string;
+declare function generateModelFieldEntry(fieldName: string, field: ContractField): string;
+declare function generateModelFieldsType(fields: Record<string, ContractField>): string;
+declare function generateModelRelationsType(relations: Record<string, unknown>): string;
+declare function generateModelsType(models: Record<string, ContractModel>, generateModelStorage: (modelName: string, model: ContractModel) => string): string;
+declare function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[];
+declare function generateImportLines(imports: TypesImportSpec[]): string[];
+declare function generateCodecTypeIntersection(imports: ReadonlyArray<TypesImportSpec>, named: string): string;
+declare function serializeExecutionType(execution: Record<string, unknown>): string;
+declare function generateHashTypeAliases(hashes: {
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}): string;
+type ResolvedFieldType = {
+  readonly input: string;
+  readonly output: string;
+};
+/**
+ * Per-family resolver for typeParams that don't live inline on the framework-domain `ContractField`. SQL columns authored via a named `storage.types` entry carry their `typeRef` on the storage column (family-specific) rather than on the framework's domain field; the per-family emitter walks `storage.types[ref].typeParams` here so the framework emit path can render the parameterized output type.
+ *
+ * Returns `undefined` when the field has no resolvable typeParams (i.e. the column isn't parameterized, isn't a `typeRef`, or the family doesn't support named storage types).
+ */
+type FieldTypeParamsResolver = (modelName: string, fieldName: string) => Record<string, unknown> | undefined;
+declare function resolveFieldType(field: ContractField, codecLookup?: CodecLookup, resolvedTypeParams?: Record<string, unknown>): ResolvedFieldType;
+declare function generateFieldResolvedType(field: ContractField, codecLookup?: CodecLookup, side?: 'input' | 'output'): string;
+declare function generateBothFieldTypesMaps(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): ResolvedFieldType;
+declare function generateFieldOutputTypesMap(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): string;
+declare function generateFieldInputTypesMap(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): string;
+declare function generateValueObjectType(_voName: string, vo: ContractValueObject, _valueObjects: Record<string, ContractValueObject>, side?: 'input' | 'output', codecLookup?: CodecLookup): string;
+declare function resolveValueObjectType(_voName: string, vo: ContractValueObject, _valueObjects: Record<string, ContractValueObject>, codecLookup?: CodecLookup): ResolvedFieldType;
+declare function generateContractFieldDescriptor(fieldName: string, field: ContractField): string;
+declare function generateValueObjectsDescriptorType(valueObjects: Record<string, ContractValueObject> | undefined): string;
+declare function generateValueObjectTypeAliases(valueObjects: Record<string, ContractValueObject> | undefined, codecLookup?: CodecLookup): string;
+//#endregion
+export { serializeObjectKey as C, serializeExecutionType as S, generateValueObjectType as _, generateCodecTypeIntersection as a, resolveFieldType as b, generateFieldOutputTypesMap as c, generateImportLines as d, generateModelFieldEntry as f, generateRootsType as g, generateModelsType as h, generateBothFieldTypesMaps as i, generateFieldResolvedType as l, generateModelRelationsType as m, ResolvedFieldType as n, generateContractFieldDescriptor as o, generateModelFieldsType as p, deduplicateImports as r, generateFieldInputTypesMap as s, FieldTypeParamsResolver as t, generateHashTypeAliases as u, generateValueObjectTypeAliases as v, serializeValue as w, resolveValueObjectType as x, generateValueObjectsDescriptorType as y };
+//# sourceMappingURL=domain-type-generation-DNECvEA1.d.mts.map

package/dist/domain-type-generation-DNECvEA1.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-type-generation-DNECvEA1.d.mts","names":[],"sources":["../src/domain-type-generation.ts"],"mappings":";;;;;iBASgB,cAAA,CAAe,KAAA;AAAA,iBA+Bf,kBAAA,CAAmB,GAAA;AAAA,iBAOnB,iBAAA,CAAkB,KAAA,EAAO,MAAA;AAAA,iBAgBzB,uBAAA,CAAwB,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAgBlD,uBAAA,CAAwB,MAAA,EAAQ,MAAA,SAAe,aAAA;AAAA,iBAQ/C,0BAAA,CAA2B,SAAA,EAAW,MAAA;AAAA,iBAsCtC,kBAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,GACvB,oBAAA,GAAuB,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAqCnC,kBAAA,CAAmB,OAAA,EAAS,eAAA,KAAoB,eAAA;AAAA,iBAahD,mBAAA,CAAoB,OAAA,EAAS,eAAA;AAAA,iBAO7B,6BAAA,CACd,OAAA,EAAS,aAAA,CAAc,eAAA,GACvB,KAAA;AAAA,iBAMc,sBAAA,CAAuB,SAAA,EAAW,MAAA;AAAA,iBASlC,uBAAA,CAAwB,MAAA;EAAA,SAC7B,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA;AAAA,KAaC,iBAAA;EAAA,SAA+B,KAAA;EAAA,SAAwB,MAAA;AAAA;;;;;;KAevD,uBAAA,IACV,SAAA,UACA,SAAA,aACG,MAAA;AAAA,iBAEW,gBAAA,CACd,KAAA,EAAO,aAAA,EACP,WAAA,GAAc,WAAA,EACd,kBAAA,GAAqB,MAAA,oBACpB,iBAAA;AAAA,iBAkDa,yBAAA,CACd,KAAA,EAAO,aAAA,EACP,WAAA,GAAc,WAAA,EACd,IAAA;AAAA,iBAKc,0BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA,GACxB,iBAAA;AAAA,iBA2Ca,2BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA;AAAA,iBAKX,0BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA;AAAA,iBAKX,uBAAA,CACd,OAAA,UACA,EAAA,EAAI,mBAAA,EACJ,aAAA,EAAe,MAAA,SAAe,mBAAA,GAC9B,IAAA,uBACA,WAAA,GAAc,WAAA;AAAA,iBAKA,sBAAA,CACd,OAAA,UACA,EAAA,EAAI,mBAAA,EACJ,aAAA,EAAe,MAAA,SAAe,mBAAA,GAC9B,WAAA,GAAc,WAAA,GACb,iBAAA;AAAA,iBAgBa,+BAAA,CAAgC,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAoB1D,kCAAA,CACd,YAAA,EAAc,MAAA,SAAe,mBAAA;AAAA,iBAoBf,8BAAA,CACd,YAAA,EAAc,MAAA,SAAe,mBAAA,eAC7B,WAAA,GAAc,WAAA"}

package/dist/domain-type-generation.d.mts

@@ -1,44 +1,2 @@
-import { ContractField, ContractModel, ContractValueObject } from "@prisma-next/contract/types";
-import { CodecLookup } from "@prisma-next/framework-components/codec";
-import { TypesImportSpec } from "@prisma-next/framework-components/emission";
-
-//#region src/domain-type-generation.d.ts
-declare function serializeValue(value: unknown): string;
-declare function serializeObjectKey(key: string): string;
-declare function generateRootsType(roots: Record<string, string> | undefined): string;
-declare function generateModelFieldEntry(fieldName: string, field: ContractField): string;
-declare function generateModelFieldsType(fields: Record<string, ContractField>): string;
-declare function generateModelRelationsType(relations: Record<string, unknown>): string;
-declare function generateModelsType(models: Record<string, ContractModel>, generateModelStorage: (modelName: string, model: ContractModel) => string): string;
-declare function deduplicateImports(imports: TypesImportSpec[]): TypesImportSpec[];
-declare function generateImportLines(imports: TypesImportSpec[]): string[];
-declare function generateCodecTypeIntersection(imports: ReadonlyArray<TypesImportSpec>, named: string): string;
-declare function serializeExecutionType(execution: Record<string, unknown>): string;
-declare function generateHashTypeAliases(hashes: {
-  readonly storageHash: string;
-  readonly executionHash?: string;
-  readonly profileHash: string;
-}): string;
-type ResolvedFieldType = {
-  readonly input: string;
-  readonly output: string;
-};
-/**
- * Per-family resolver for typeParams that don't live inline on the framework-domain `ContractField`. SQL columns authored via a named `storage.types` entry carry their `typeRef` on the storage column (family-specific) rather than on the framework's domain field; the per-family emitter walks `storage.types[ref].typeParams` here so the framework emit path can render the parameterized output type.
- *
- * Returns `undefined` when the field has no resolvable typeParams (i.e. the column isn't parameterized, isn't a `typeRef`, or the family doesn't support named storage types).
- */
-type FieldTypeParamsResolver = (modelName: string, fieldName: string) => Record<string, unknown> | undefined;
-declare function resolveFieldType(field: ContractField, codecLookup?: CodecLookup, resolvedTypeParams?: Record<string, unknown>): ResolvedFieldType;
-declare function generateFieldResolvedType(field: ContractField, codecLookup?: CodecLookup, side?: 'input' | 'output'): string;
-declare function generateBothFieldTypesMaps(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): ResolvedFieldType;
-declare function generateFieldOutputTypesMap(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): string;
-declare function generateFieldInputTypesMap(models: Record<string, ContractModel> | undefined, codecLookup?: CodecLookup, resolveFieldTypeParams?: FieldTypeParamsResolver): string;
-declare function generateValueObjectType(_voName: string, vo: ContractValueObject, _valueObjects: Record<string, ContractValueObject>, side?: 'input' | 'output', codecLookup?: CodecLookup): string;
-declare function resolveValueObjectType(_voName: string, vo: ContractValueObject, _valueObjects: Record<string, ContractValueObject>, codecLookup?: CodecLookup): ResolvedFieldType;
-declare function generateContractFieldDescriptor(fieldName: string, field: ContractField): string;
-declare function generateValueObjectsDescriptorType(valueObjects: Record<string, ContractValueObject> | undefined): string;
-declare function generateValueObjectTypeAliases(valueObjects: Record<string, ContractValueObject> | undefined, codecLookup?: CodecLookup): string;
-//#endregion
-export { FieldTypeParamsResolver, ResolvedFieldType, deduplicateImports, generateBothFieldTypesMaps, generateCodecTypeIntersection, generateContractFieldDescriptor, generateFieldInputTypesMap, generateFieldOutputTypesMap, generateFieldResolvedType, generateHashTypeAliases, generateImportLines, generateModelFieldEntry, generateModelFieldsType, generateModelRelationsType, generateModelsType, generateRootsType, generateValueObjectType, generateValueObjectTypeAliases, generateValueObjectsDescriptorType, resolveFieldType, resolveValueObjectType, serializeExecutionType, serializeObjectKey, serializeValue };
-//# sourceMappingURL=domain-type-generation.d.mts.map
+import { C as serializeObjectKey, S as serializeExecutionType, _ as generateValueObjectType, a as generateCodecTypeIntersection, b as resolveFieldType, c as generateFieldOutputTypesMap, d as generateImportLines, f as generateModelFieldEntry, g as generateRootsType, h as generateModelsType, i as generateBothFieldTypesMaps, l as generateFieldResolvedType, m as generateModelRelationsType, n as ResolvedFieldType, o as generateContractFieldDescriptor, p as generateModelFieldsType, r as deduplicateImports, s as generateFieldInputTypesMap, t as FieldTypeParamsResolver, u as generateHashTypeAliases, v as generateValueObjectTypeAliases, w as serializeValue, x as resolveValueObjectType, y as generateValueObjectsDescriptorType } from "./domain-type-generation-DNECvEA1.mjs";
+export { FieldTypeParamsResolver, ResolvedFieldType, deduplicateImports, generateBothFieldTypesMaps, generateCodecTypeIntersection, generateContractFieldDescriptor, generateFieldInputTypesMap, generateFieldOutputTypesMap, generateFieldResolvedType, generateHashTypeAliases, generateImportLines, generateModelFieldEntry, generateModelFieldsType, generateModelRelationsType, generateModelsType, generateRootsType, generateValueObjectType, generateValueObjectTypeAliases, generateValueObjectsDescriptorType, resolveFieldType, resolveValueObjectType, serializeExecutionType, serializeObjectKey, serializeValue };

package/dist/exports/index.d.mts

@@ -1,47 +1,3 @@
-import { deduplicateImports, generateCodecTypeIntersection, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue } from "../domain-type-generation.mjs";
-import { Contract } from "@prisma-next/contract/types";
-import { CodecLookup } from "@prisma-next/framework-components/codec";
-import { EmissionSpi, GenerateContractTypesOptions, TypesImportSpec } from "@prisma-next/framework-components/emission";
-
-//#region src/artifact-paths.d.ts
-interface EmittedArtifactPaths {
-  readonly jsonPath: string;
-  readonly dtsPath: string;
-}
-declare function getEmittedArtifactPaths(outputJsonPath: string): EmittedArtifactPaths;
-//#endregion
-//#region src/emit-types.d.ts
-/**
- * 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.
- */
-interface EmitStackInput {
-  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
-  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
-  readonly extensionIds?: ReadonlyArray<string>;
-  readonly codecLookup?: CodecLookup;
-}
-interface EmitOptions {
-  readonly outputJsonPath?: string;
-}
-interface EmitResult {
-  readonly contractJson: string;
-  readonly contractDts: string;
-  readonly storageHash: string;
-  readonly executionHash?: string;
-  readonly profileHash: string;
-}
-//#endregion
-//#region src/emit.d.ts
-declare function emit(contract: Contract, stack: EmitStackInput, targetFamily: EmissionSpi, options?: EmitOptions): Promise<EmitResult>;
-//#endregion
-//#region src/generate-contract-dts.d.ts
-declare function generateContractDts(contract: Contract, emitter: EmissionSpi, codecTypeImports: ReadonlyArray<TypesImportSpec>, hashes: {
-  readonly storageHash: string;
-  readonly executionHash?: string;
-  readonly profileHash: string;
-}, options?: GenerateContractTypesOptions, codecLookup?: CodecLookup): string;
-//#endregion
-export { type EmitResult, type EmitStackInput, type EmittedArtifactPaths, deduplicateImports, emit, generateCodecTypeIntersection, generateContractDts, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, getEmittedArtifactPaths, serializeObjectKey, serializeValue };
-//# sourceMappingURL=index.d.mts.map
+import { C as serializeObjectKey, a as generateCodecTypeIntersection, c as generateFieldOutputTypesMap, d as generateImportLines, g as generateRootsType, m as generateModelRelationsType, r as deduplicateImports, u as generateHashTypeAliases, w as serializeValue } from "../domain-type-generation-DNECvEA1.mjs";
+import { a as EmitStackInput, i as EmitResult, n as emit, o as EmittedArtifactPaths, r as EmitOptions, s as getEmittedArtifactPaths, t as generateContractDts } from "../index-BPiSzH-y.mjs";
+export { EmitOptions, EmitResult, EmitStackInput, EmittedArtifactPaths, deduplicateImports, emit, generateCodecTypeIntersection, generateContractDts, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, getEmittedArtifactPaths, serializeObjectKey, serializeValue };

package/dist/exports/index.mjs

@@ -1,118 +1,3 @@
-import { deduplicateImports, generateBothFieldTypesMaps, generateCodecTypeIntersection, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateModelsType, generateRootsType, generateValueObjectTypeAliases, generateValueObjectsDescriptorType, serializeExecutionType, serializeObjectKey, serializeValue } from "../domain-type-generation.mjs";
-import { canonicalizeContractToObject } from "@prisma-next/contract/hashing";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { format } from "prettier";
-//#region src/artifact-paths.ts
-const JSON_EXTENSION = ".json";
-function getEmittedArtifactPaths(outputJsonPath) {
-	if (!outputJsonPath.endsWith(JSON_EXTENSION)) throw new Error("Contract output path must end with .json");
-	return {
-		jsonPath: outputJsonPath,
-		dtsPath: `${outputJsonPath.slice(0, -5)}.d.ts`
-	};
-}
-//#endregion
-//#region src/generate-contract-dts.ts
-function generateContractDts(contract, emitter, codecTypeImports, hashes, options, codecLookup) {
-	const allImports = [...codecTypeImports];
-	if (options?.queryOperationTypeImports) allImports.push(...options.queryOperationTypeImports);
-	const importLines = generateImportLines(deduplicateImports(allImports));
-	const familyImportLines = emitter.getFamilyImports();
-	const hashAliases = generateHashTypeAliases(hashes);
-	const codecTypes = generateCodecTypeIntersection(codecTypeImports, "CodecTypes");
-	const familyTypeAliases = emitter.getFamilyTypeAliases(options);
-	const typeMapsExpr = emitter.getTypeMapsExpression();
-	const storageType = emitter.generateStorageType(contract, "StorageHash");
-	const modelsType = generateModelsType(contract.models, (name, model) => emitter.generateModelStorageType(name, model));
-	const rootsType = generateRootsType(contract.roots);
-	const valueObjects = contract.valueObjects;
-	const valueObjectTypeAliases = generateValueObjectTypeAliases(valueObjects, codecLookup);
-	const valueObjectsDescriptor = generateValueObjectsDescriptorType(valueObjects);
-	const executionClause = contract.execution !== void 0 ? `\n  readonly execution: ${serializeExecutionType(contract.execution)};` : "";
-	const resolveFieldTypeParams = emitter.resolveFieldTypeParams ? (modelName, fieldName) => {
-		const model = contract.models?.[modelName];
-		if (!model) return void 0;
-		return emitter.resolveFieldTypeParams?.(modelName, fieldName, model, contract);
-	} : void 0;
-	const fieldTypesMaps = generateBothFieldTypesMaps(contract.models, codecLookup, resolveFieldTypeParams);
-	const contractWrapper = emitter.getContractWrapper("ContractBase", "TypeMaps");
-	return `// ⚠️  GENERATED FILE - DO NOT EDIT
-// This file is automatically generated by 'prisma-next contract emit'.
-// To regenerate, run: prisma-next contract emit
-${importLines.join("\n")}
-
-${familyImportLines.join("\n")}
-import type {
-  Contract as ContractType,
-  ExecutionHashBase,
-  ProfileHashBase,
-  StorageHashBase,
-} from '@prisma-next/contract/types';
-
-${hashAliases}
-
-export type CodecTypes = ${codecTypes};
-${familyTypeAliases}
-${valueObjectTypeAliases}
-export type FieldOutputTypes = ${fieldTypesMaps.output};
-export type FieldInputTypes = ${fieldTypesMaps.input};
-export type TypeMaps = ${typeMapsExpr};
-
-type ContractBase = ContractType<
-${storageType},
-${modelsType}
-> & {
-  readonly target: ${serializeValue(contract.target)};
-  readonly targetFamily: ${serializeValue(contract.targetFamily)};
-  readonly roots: ${rootsType};
-  readonly capabilities: ${serializeValue(contract.capabilities)};
-  readonly extensionPacks: ${serializeValue(contract.extensionPacks)};${executionClause}
-  readonly meta: ${serializeValue(contract.meta)};
-  ${valueObjects ? `readonly valueObjects: ${valueObjectsDescriptor};` : ""}
-  readonly profileHash: ProfileHash;
-};
-
-${contractWrapper}
-`;
-}
-//#endregion
-//#region src/emit.ts
-const SCHEMA_VERSION = "1";
-async function emit(contract, stack, targetFamily, options) {
-	if (options?.outputJsonPath !== void 0) getEmittedArtifactPaths(options.outputJsonPath);
-	const { codecTypeImports, 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 } : void 0;
-	const contractTypeHashes = {
-		storageHash,
-		...ifDefined("executionHash", executionHash),
-		profileHash
-	};
-	return {
-		contractJson: contractJsonString,
-		contractDts: await format(generateContractDts(contract, targetFamily, codecTypeImports ?? [], contractTypeHashes, generateOptions, stack.codecLookup), {
-			parser: "typescript",
-			singleQuote: true,
-			semi: true,
-			printWidth: 100
-		}),
-		storageHash,
-		...ifDefined("executionHash", executionHash),
-		profileHash
-	};
-}
-//#endregion
+import { n as generateContractDts, r as getEmittedArtifactPaths, t as emit } from "../exports-DF8AW-FF.mjs";
+import { deduplicateImports, generateCodecTypeIntersection, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, serializeObjectKey, serializeValue } from "../domain-type-generation.mjs";
 export { deduplicateImports, emit, generateCodecTypeIntersection, generateContractDts, generateFieldOutputTypesMap, generateHashTypeAliases, generateImportLines, generateModelRelationsType, generateRootsType, getEmittedArtifactPaths, serializeObjectKey, serializeValue };
-
-//# sourceMappingURL=index.mjs.map

package/dist/exports-DF8AW-FF.mjs

@@ -0,0 +1,121 @@
+import { deduplicateImports, generateBothFieldTypesMaps, generateCodecTypeIntersection, generateHashTypeAliases, generateImportLines, generateModelsType, generateRootsType, generateValueObjectTypeAliases, generateValueObjectsDescriptorType, serializeExecutionType, serializeValue } from "./domain-type-generation.mjs";
+import { canonicalizeContractToObject } from "@prisma-next/contract/hashing";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { format } from "prettier";
+//#region src/artifact-paths.ts
+const JSON_EXTENSION = ".json";
+function getEmittedArtifactPaths(outputJsonPath) {
+	if (!outputJsonPath.endsWith(JSON_EXTENSION)) throw new Error("Contract output path must end with .json");
+	return {
+		jsonPath: outputJsonPath,
+		dtsPath: `${outputJsonPath.slice(0, -5)}.d.ts`
+	};
+}
+//#endregion
+//#region src/generate-contract-dts.ts
+function generateContractDts(contract, emitter, codecTypeImports, hashes, options, codecLookup) {
+	const allImports = [...codecTypeImports];
+	if (options?.queryOperationTypeImports) allImports.push(...options.queryOperationTypeImports);
+	const importLines = generateImportLines(deduplicateImports(allImports));
+	const familyImportLines = emitter.getFamilyImports();
+	const hashAliases = generateHashTypeAliases(hashes);
+	const codecTypes = generateCodecTypeIntersection(codecTypeImports, "CodecTypes");
+	const familyTypeAliases = emitter.getFamilyTypeAliases(options);
+	const typeMapsExpr = emitter.getTypeMapsExpression();
+	const storageType = emitter.generateStorageType(contract, "StorageHash");
+	const modelsType = generateModelsType(contract.models, (name, model) => emitter.generateModelStorageType(name, model));
+	const rootsType = generateRootsType(contract.roots);
+	const valueObjects = contract.valueObjects;
+	const valueObjectTypeAliases = generateValueObjectTypeAliases(valueObjects, codecLookup);
+	const valueObjectsDescriptor = generateValueObjectsDescriptorType(valueObjects);
+	const executionClause = contract.execution !== void 0 ? `\n  readonly execution: ${serializeExecutionType(contract.execution)};` : "";
+	const resolveFieldTypeParams = emitter.resolveFieldTypeParams ? (modelName, fieldName) => {
+		const model = contract.models?.[modelName];
+		if (!model) return void 0;
+		return emitter.resolveFieldTypeParams?.(modelName, fieldName, model, contract);
+	} : void 0;
+	const fieldTypesMaps = generateBothFieldTypesMaps(contract.models, codecLookup, resolveFieldTypeParams);
+	const contractWrapper = emitter.getContractWrapper("ContractBase", "TypeMaps");
+	return `// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+${importLines.join("\n")}
+
+${familyImportLines.join("\n")}
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+${hashAliases}
+
+export type CodecTypes = ${codecTypes};
+${familyTypeAliases}
+${valueObjectTypeAliases}
+export type FieldOutputTypes = ${fieldTypesMaps.output};
+export type FieldInputTypes = ${fieldTypesMaps.input};
+export type TypeMaps = ${typeMapsExpr};
+
+type ContractBase = ContractType<
+${storageType},
+${modelsType}
+> & {
+  readonly target: ${serializeValue(contract.target)};
+  readonly targetFamily: ${serializeValue(contract.targetFamily)};
+  readonly roots: ${rootsType};
+  readonly capabilities: ${serializeValue(contract.capabilities)};
+  readonly extensionPacks: ${serializeValue(contract.extensionPacks)};${executionClause}
+  readonly meta: ${serializeValue(contract.meta)};
+  ${valueObjects ? `readonly valueObjects: ${valueObjectsDescriptor};` : ""}
+  readonly profileHash: ProfileHash;
+};
+
+${contractWrapper}
+`;
+}
+//#endregion
+//#region src/emit.ts
+const SCHEMA_VERSION = "1";
+async function emit(contract, stack, targetFamily, options) {
+	if (options.outputJsonPath !== void 0) getEmittedArtifactPaths(options.outputJsonPath);
+	const { codecTypeImports, queryOperationTypeImports } = stack;
+	const { storageHash } = contract.storage;
+	const executionHash = contract.execution?.executionHash;
+	const { profileHash } = contract;
+	const canonicalized = canonicalizeContractToObject(contract, {
+		schemaVersion: SCHEMA_VERSION,
+		serializeContract: options.serializeContract
+	});
+	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 } : void 0;
+	const contractTypeHashes = {
+		storageHash,
+		...ifDefined("executionHash", executionHash),
+		profileHash
+	};
+	return {
+		contractJson: contractJsonString,
+		contractDts: await format(generateContractDts(contract, targetFamily, codecTypeImports ?? [], contractTypeHashes, generateOptions, stack.codecLookup), {
+			parser: "typescript",
+			singleQuote: true,
+			semi: true,
+			printWidth: 100
+		}),
+		storageHash,
+		...ifDefined("executionHash", executionHash),
+		profileHash
+	};
+}
+//#endregion
+export { generateContractDts as n, getEmittedArtifactPaths as r, emit as t };
+
+//# sourceMappingURL=exports-DF8AW-FF.mjs.map

package/dist/exports-DF8AW-FF.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports-DF8AW-FF.mjs","names":[],"sources":["../src/artifact-paths.ts","../src/generate-contract-dts.ts","../src/emit.ts"],"sourcesContent":["const JSON_EXTENSION = '.json';\n\nexport interface EmittedArtifactPaths {\n  readonly jsonPath: string;\n  readonly dtsPath: string;\n}\n\nexport function getEmittedArtifactPaths(outputJsonPath: string): EmittedArtifactPaths {\n  if (!outputJsonPath.endsWith(JSON_EXTENSION)) {\n    throw new Error('Contract output path must end with .json');\n  }\n\n  return {\n    jsonPath: outputJsonPath,\n    dtsPath: `${outputJsonPath.slice(0, -JSON_EXTENSION.length)}.d.ts`,\n  };\n}\n","import type { Contract, ContractModel, ContractValueObject } from '@prisma-next/contract/types';\nimport type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport type {\n  EmissionSpi,\n  GenerateContractTypesOptions,\n  TypesImportSpec,\n} from '@prisma-next/framework-components/emission';\nimport {\n  deduplicateImports,\n  generateBothFieldTypesMaps,\n  generateCodecTypeIntersection,\n  generateHashTypeAliases,\n  generateImportLines,\n  generateModelsType,\n  generateRootsType,\n  generateValueObjectsDescriptorType,\n  generateValueObjectTypeAliases,\n  serializeExecutionType,\n  serializeValue,\n} from './domain-type-generation';\n\nexport function generateContractDts(\n  contract: Contract,\n  emitter: EmissionSpi,\n  codecTypeImports: ReadonlyArray<TypesImportSpec>,\n  hashes: {\n    readonly storageHash: string;\n    readonly executionHash?: string;\n    readonly profileHash: string;\n  },\n  options?: GenerateContractTypesOptions,\n  codecLookup?: CodecLookup,\n): string {\n  const allImports: TypesImportSpec[] = [...codecTypeImports];\n  if (options?.queryOperationTypeImports) {\n    allImports.push(...options.queryOperationTypeImports);\n  }\n  const uniqueImports = deduplicateImports(allImports);\n  const importLines = generateImportLines(uniqueImports);\n\n  const familyImportLines = emitter.getFamilyImports();\n\n  const hashAliases = generateHashTypeAliases(hashes);\n\n  const codecTypes = generateCodecTypeIntersection(codecTypeImports, 'CodecTypes');\n\n  const familyTypeAliases = emitter.getFamilyTypeAliases(options);\n\n  const typeMapsExpr = emitter.getTypeMapsExpression();\n\n  const storageType = emitter.generateStorageType(contract, 'StorageHash');\n\n  const modelsType = generateModelsType(\n    contract.models as Record<string, ContractModel>,\n    (name, model) => emitter.generateModelStorageType(name, model),\n  );\n\n  const rootsType = generateRootsType(contract.roots);\n\n  const valueObjects = contract.valueObjects as Record<string, ContractValueObject> | undefined;\n  const valueObjectTypeAliases = generateValueObjectTypeAliases(valueObjects, codecLookup);\n  const valueObjectsDescriptor = generateValueObjectsDescriptorType(valueObjects);\n\n  const executionClause =\n    contract.execution !== undefined\n      ? `\\n  readonly execution: ${serializeExecutionType(contract.execution)};`\n      : '';\n\n  const resolveFieldTypeParams = emitter.resolveFieldTypeParams\n    ? (modelName: string, fieldName: string) => {\n        const model = (contract.models as Record<string, ContractModel> | undefined)?.[modelName];\n        if (!model) return undefined;\n        return emitter.resolveFieldTypeParams?.(modelName, fieldName, model, contract);\n      }\n    : undefined;\n\n  const fieldTypesMaps = generateBothFieldTypesMaps(\n    contract.models as Record<string, ContractModel> | undefined,\n    codecLookup,\n    resolveFieldTypeParams,\n  );\n\n  const contractWrapper = emitter.getContractWrapper('ContractBase', 'TypeMaps');\n\n  return `// ⚠️  GENERATED FILE - DO NOT EDIT\n// This file is automatically generated by 'prisma-next contract emit'.\n// To regenerate, run: prisma-next contract emit\n${importLines.join('\\n')}\n\n${familyImportLines.join('\\n')}\nimport type {\n  Contract as ContractType,\n  ExecutionHashBase,\n  ProfileHashBase,\n  StorageHashBase,\n} from '@prisma-next/contract/types';\n\n${hashAliases}\n\nexport type CodecTypes = ${codecTypes};\n${familyTypeAliases}\n${valueObjectTypeAliases}\nexport type FieldOutputTypes = ${fieldTypesMaps.output};\nexport type FieldInputTypes = ${fieldTypesMaps.input};\nexport type TypeMaps = ${typeMapsExpr};\n\ntype ContractBase = ContractType<\n${storageType},\n${modelsType}\n> & {\n  readonly target: ${serializeValue(contract.target)};\n  readonly targetFamily: ${serializeValue(contract.targetFamily)};\n  readonly roots: ${rootsType};\n  readonly capabilities: ${serializeValue(contract.capabilities)};\n  readonly extensionPacks: ${serializeValue(contract.extensionPacks)};${executionClause}\n  readonly meta: ${serializeValue(contract.meta)};\n  ${valueObjects ? `readonly valueObjects: ${valueObjectsDescriptor};` : ''}\n  readonly profileHash: ProfileHash;\n};\n\n${contractWrapper}\n`;\n}\n","import { canonicalizeContractToObject } from '@prisma-next/contract/hashing';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { EmissionSpi } from '@prisma-next/framework-components/emission';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { format } from 'prettier';\nimport { getEmittedArtifactPaths } from './artifact-paths';\nimport type { EmitOptions, EmitResult, EmitStackInput } from './emit-types';\nimport { generateContractDts } from './generate-contract-dts';\n\nconst SCHEMA_VERSION = '1';\n\nexport async function emit(\n  contract: Contract,\n  stack: EmitStackInput,\n  targetFamily: EmissionSpi,\n  options: EmitOptions,\n): Promise<EmitResult> {\n  if (options.outputJsonPath !== undefined) {\n    getEmittedArtifactPaths(options.outputJsonPath);\n  }\n\n  const { codecTypeImports, queryOperationTypeImports } = stack;\n\n  const { storageHash } = contract.storage;\n  const executionHash = contract.execution?.executionHash;\n  const { profileHash } = contract;\n\n  const canonicalized = canonicalizeContractToObject(contract, {\n    schemaVersion: SCHEMA_VERSION,\n    serializeContract: options.serializeContract,\n  });\n  const contractJsonString = JSON.stringify(\n    {\n      ...canonicalized,\n      _generated: {\n        warning: '⚠️  GENERATED FILE - DO NOT EDIT',\n        message: 'This file is automatically generated by \"prisma-next contract emit\".',\n        regenerate: 'To regenerate, run: prisma-next contract emit',\n      },\n    },\n    null,\n    2,\n  );\n\n  const generateOptions = queryOperationTypeImports ? { queryOperationTypeImports } : undefined;\n\n  const contractTypeHashes = {\n    storageHash,\n    ...ifDefined('executionHash', executionHash),\n    profileHash,\n  };\n  const contractDtsRaw = generateContractDts(\n    contract,\n    targetFamily,\n    codecTypeImports ?? [],\n    contractTypeHashes,\n    generateOptions,\n    stack.codecLookup,\n  );\n  const contractDts = await format(contractDtsRaw, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n\n  return {\n    contractJson: contractJsonString,\n    contractDts,\n    storageHash,\n    ...ifDefined('executionHash', executionHash),\n    profileHash,\n  };\n}\n"],"mappings":"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"}

package/dist/index-BPiSzH-y.d.mts

@@ -0,0 +1,57 @@
+import { SerializeContract } from "@prisma-next/contract/hashing";
+import { Contract } from "@prisma-next/contract/types";
+import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { EmissionSpi, GenerateContractTypesOptions, TypesImportSpec } from "@prisma-next/framework-components/emission";
+
+//#region src/artifact-paths.d.ts
+interface EmittedArtifactPaths {
+  readonly jsonPath: string;
+  readonly dtsPath: string;
+}
+declare function getEmittedArtifactPaths(outputJsonPath: string): EmittedArtifactPaths;
+//#endregion
+//#region src/emit-types.d.ts
+/**
+ * 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.
+ */
+interface EmitStackInput {
+  readonly codecTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly queryOperationTypeImports?: ReadonlyArray<TypesImportSpec>;
+  readonly extensionIds?: ReadonlyArray<string>;
+  readonly codecLookup?: CodecLookup;
+}
+interface EmitOptions {
+  readonly outputJsonPath?: string;
+  /**
+   * Per-target serializer that converts the in-memory contract into its
+   * canonical on-disk JsonObject shape before the framework's
+   * key-ordering / default-omission walk runs. Threaded from the
+   * descriptor (`descriptor.contractSerializer.serializeContract`) at
+   * the CLI / control-API call site so target classes decide what
+   * appears in the JSON envelope rather than the framework guessing
+   * via property enumerability.
+   */
+  readonly serializeContract: SerializeContract;
+}
+interface EmitResult {
+  readonly contractJson: string;
+  readonly contractDts: string;
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}
+//#endregion
+//#region src/emit.d.ts
+declare function emit(contract: Contract, stack: EmitStackInput, targetFamily: EmissionSpi, options: EmitOptions): Promise<EmitResult>;
+//#endregion
+//#region src/generate-contract-dts.d.ts
+declare function generateContractDts(contract: Contract, emitter: EmissionSpi, codecTypeImports: ReadonlyArray<TypesImportSpec>, hashes: {
+  readonly storageHash: string;
+  readonly executionHash?: string;
+  readonly profileHash: string;
+}, options?: GenerateContractTypesOptions, codecLookup?: CodecLookup): string;
+//#endregion
+export { EmitStackInput as a, EmitResult as i, emit as n, EmittedArtifactPaths as o, EmitOptions as r, getEmittedArtifactPaths as s, generateContractDts as t };
+//# sourceMappingURL=index-BPiSzH-y.d.mts.map

package/dist/index-BPiSzH-y.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BPiSzH-y.d.mts","names":[],"sources":["../src/artifact-paths.ts","../src/emit-types.ts","../src/emit.ts","../src/generate-contract-dts.ts"],"mappings":";;;;;;UAEiB,oBAAA;EAAA,SACN,QAAA;EAAA,SACA,OAAA;AAAA;AAAA,iBAGK,uBAAA,CAAwB,cAAA,WAAyB,oBAAA;;;;;;;AALjE;UCOiB,cAAA;EAAA,SACN,gBAAA,GAAmB,aAAA,CAAc,eAAA;EAAA,SACjC,yBAAA,GAA4B,aAAA,CAAc,eAAA;EAAA,SAC1C,YAAA,GAAe,aAAA;EAAA,SACf,WAAA,GAAc,WAAA;AAAA;AAAA,UAGR,WAAA;EAAA,SACN,cAAA;EDV0E;;;;ACErF;;;;;EDFqF,SCoB1E,iBAAA,EAAmB,iBAAA;AAAA;AAAA,UAGb,UAAA;EAAA,SACN,YAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA;;;iBCxBW,IAAA,CACpB,QAAA,EAAU,QAAA,EACV,KAAA,EAAO,cAAA,EACP,YAAA,EAAc,WAAA,EACd,OAAA,EAAS,WAAA,GACR,OAAA,CAAQ,UAAA;;;iBCKK,mBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,WAAA,EACT,gBAAA,EAAkB,aAAA,CAAc,eAAA,GAChC,MAAA;EAAA,SACW,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA,GAEX,OAAA,GAAU,4BAAA,EACV,WAAA,GAAc,WAAA"}

package/dist/test/utils.d.mts

@@ -1,6 +1,14 @@
+import { a as EmitStackInput, i as EmitResult, r as EmitOptions } from "../index-BPiSzH-y.mjs";
 import { Contract } from "@prisma-next/contract/types";
+import { EmissionSpi } from "@prisma-next/framework-components/emission";
 
 //#region test/utils.d.ts
+/**
+ * Tests author JSON-clean contracts directly, so the canonicalisation
+ * hook trivially passes through. Production callers thread the target
+ * descriptor's `contractSerializer.serializeContract` instead.
+ */
+declare function emit(contract: Contract, stack: EmitStackInput, family: EmissionSpi, options?: Omit<EmitOptions, 'serializeContract'>): Promise<EmitResult>;
 type TestContractOverrides = {
   target?: string;
   targetFamily?: string;
@@ -17,5 +25,5 @@ type TestContractOverrides = {
 };
 declare function createTestContract(overrides?: TestContractOverrides): Contract;
 //#endregion
-export { createTestContract };
+export { createTestContract, emit };
 //# 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"],"mappings":";;;KAGK,qBAAA;EACH,MAAA;EACA,YAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;EACT,OAAA,GAAU,MAAA;EACV,YAAA,GAAe,MAAA,SAAe,MAAA;EAC9B,cAAA,GAAiB,MAAA;EACjB,SAAA,GAAY,MAAA;EACZ,IAAA,GAAO,MAAA;EACP,WAAA;EACA,aAAA;EACA,OAAA,GAAU,MAAA;AAAA;AAAA,iBAGI,kBAAA,CAAmB,SAAA,GAAW,qBAAA,GAA6B,QAAA"}
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../test/utils.ts"],"mappings":";;;;;;;AAcA;;;iBAAgB,IAAA,CACd,QAAA,EAAU,QAAA,EACV,KAAA,EAAO,cAAA,EACP,MAAA,EAAQ,WAAA,EACR,OAAA,GAAU,IAAA,CAAK,WAAA,yBACd,OAAA,CAAQ,UAAA;AAAA,KAON,qBAAA;EACH,MAAA;EACA,YAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;EACT,OAAA,GAAU,MAAA;EACV,YAAA,GAAe,MAAA,SAAe,MAAA;EAC9B,cAAA,GAAiB,MAAA;EACjB,SAAA,GAAY,MAAA;EACZ,IAAA,GAAO,MAAA;EACP,WAAA;EACA,aAAA;EACA,OAAA,GAAU,MAAA;AAAA;AAAA,iBAGI,kBAAA,CAAmB,SAAA,GAAW,qBAAA,GAA6B,QAAA"}

package/dist/test/utils.mjs

@@ -1,5 +1,18 @@
+import { t as emit$1 } from "../exports-DF8AW-FF.mjs";
 import { createContract } from "@prisma-next/contract/testing";
 //#region test/utils.ts
+const identitySerialize = (c) => c;
+/**
+* Tests author JSON-clean contracts directly, so the canonicalisation
+* hook trivially passes through. Production callers thread the target
+* descriptor's `contractSerializer.serializeContract` instead.
+*/
+function emit(contract, stack, family, options) {
+	return emit$1(contract, stack, family, {
+		...options,
+		serializeContract: identitySerialize
+	});
+}
 function createTestContract(overrides = {}) {
 	const { storageHash: _sh, schemaVersion: _sv, sources: _src, storage, ...rest } = overrides;
 	const cleanStorage = storage ? (() => {
@@ -12,6 +25,6 @@ function createTestContract(overrides = {}) {
 	});
 }
 //#endregion
-export { createTestContract };
+export { createTestContract, emit };
 
 //# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -1 +1 @@
-{"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;EAClD,OAAO;KACL,GACJ,KAAA;CACJ,OAAO,eAAe;EACpB,GAAG;EACH,GAAI,eAAe,EAAE,SAAS,cAAc,GAAG,EAAE;EAClD,CAAyC"}
+{"version":3,"file":"utils.mjs","names":["emitImpl"],"sources":["../../test/utils.ts"],"sourcesContent":["import { createContract } from '@prisma-next/contract/testing';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { EmissionSpi } from '@prisma-next/framework-components/emission';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport type { EmitOptions, EmitResult, EmitStackInput } from '../src/exports';\nimport { emit as emitImpl } from '../src/exports';\n\nconst identitySerialize = (c: Contract): JsonObject => c as unknown as JsonObject;\n\n/**\n * Tests author JSON-clean contracts directly, so the canonicalisation\n * hook trivially passes through. Production callers thread the target\n * descriptor's `contractSerializer.serializeContract` instead.\n */\nexport function emit(\n  contract: Contract,\n  stack: EmitStackInput,\n  family: EmissionSpi,\n  options?: Omit<EmitOptions, 'serializeContract'>,\n): Promise<EmitResult> {\n  return emitImpl(contract, stack, family, {\n    ...options,\n    serializeContract: identitySerialize,\n  });\n}\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":";;;AAOA,MAAM,qBAAqB,MAA4B;;;;;;AAOvD,SAAgB,KACd,UACA,OACA,QACA,SACqB;CACrB,OAAOA,OAAS,UAAU,OAAO,QAAQ;EACvC,GAAG;EACH,mBAAmB;EACpB,CAAC;;AAkBJ,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;EAClD,OAAO;KACL,GACJ,KAAA;CACJ,OAAO,eAAe;EACpB,GAAG;EACH,GAAI,eAAe,EAAE,SAAS,cAAc,GAAG,EAAE;EAClD,CAAyC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/emitter",
-  "version": "0.8.0",
+  "version": "0.9.0-dev.1",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,18 +9,18 @@
     "src"
   ],
   "dependencies": {
-    "@prisma-next/contract": "0.8.0",
-    "@prisma-next/framework-components": "0.8.0",
-    "@prisma-next/operations": "0.8.0",
-    "@prisma-next/utils": "0.8.0",
+    "@prisma-next/contract": "0.9.0-dev.1",
+    "@prisma-next/framework-components": "0.9.0-dev.1",
+    "@prisma-next/operations": "0.9.0-dev.1",
+    "@prisma-next/utils": "0.9.0-dev.1",
     "arktype": "^2.1.29",
     "prettier": "^3.8.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.8.0",
-    "@prisma-next/tsconfig": "0.8.0",
+    "@prisma-next/test-utils": "0.9.0-dev.1",
+    "@prisma-next/tsconfig": "0.9.0-dev.1",
     "@types/node": "24.10.4",
-    "@prisma-next/tsdown": "0.8.0",
+    "@prisma-next/tsdown": "0.9.0-dev.1",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5"

package/src/emit-types.ts

@@ -1,3 +1,4 @@
+import type { SerializeContract } from '@prisma-next/contract/hashing';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 
@@ -15,6 +16,16 @@ export interface EmitStackInput {
 
 export interface EmitOptions {
   readonly outputJsonPath?: string;
+  /**
+   * Per-target serializer that converts the in-memory contract into its
+   * canonical on-disk JsonObject shape before the framework's
+   * key-ordering / default-omission walk runs. Threaded from the
+   * descriptor (`descriptor.contractSerializer.serializeContract`) at
+   * the CLI / control-API call site so target classes decide what
+   * appears in the JSON envelope rather than the framework guessing
+   * via property enumerability.
+   */
+  readonly serializeContract: SerializeContract;
 }
 
 export interface EmitResult {

package/src/emit.ts

@@ -13,9 +13,9 @@ export async function emit(
   contract: Contract,
   stack: EmitStackInput,
   targetFamily: EmissionSpi,
-  options?: EmitOptions,
+  options: EmitOptions,
 ): Promise<EmitResult> {
-  if (options?.outputJsonPath !== undefined) {
+  if (options.outputJsonPath !== undefined) {
     getEmittedArtifactPaths(options.outputJsonPath);
   }
 
@@ -27,6 +27,7 @@ export async function emit(
 
   const canonicalized = canonicalizeContractToObject(contract, {
     schemaVersion: SCHEMA_VERSION,
+    serializeContract: options.serializeContract,
   });
   const contractJsonString = JSON.stringify(
     {

package/src/exports/index.ts

@@ -12,5 +12,5 @@ export {
   serializeValue,
 } from '../domain-type-generation';
 export { emit } from '../emit';
-export type { EmitResult, EmitStackInput } from '../emit-types';
+export type { EmitOptions, EmitResult, EmitStackInput } from '../emit-types';
 export { generateContractDts } from '../generate-contract-dts';

package/dist/domain-type-generation.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain-type-generation.d.mts","names":[],"sources":["../src/domain-type-generation.ts"],"mappings":";;;;;iBASgB,cAAA,CAAe,KAAA;AAAA,iBA+Bf,kBAAA,CAAmB,GAAA;AAAA,iBAOnB,iBAAA,CAAkB,KAAA,EAAO,MAAA;AAAA,iBAgBzB,uBAAA,CAAwB,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAgBlD,uBAAA,CAAwB,MAAA,EAAQ,MAAA,SAAe,aAAA;AAAA,iBAQ/C,0BAAA,CAA2B,SAAA,EAAW,MAAA;AAAA,iBAsCtC,kBAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,GACvB,oBAAA,GAAuB,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAqCnC,kBAAA,CAAmB,OAAA,EAAS,eAAA,KAAoB,eAAA;AAAA,iBAahD,mBAAA,CAAoB,OAAA,EAAS,eAAA;AAAA,iBAO7B,6BAAA,CACd,OAAA,EAAS,aAAA,CAAc,eAAA,GACvB,KAAA;AAAA,iBAMc,sBAAA,CAAuB,SAAA,EAAW,MAAA;AAAA,iBASlC,uBAAA,CAAwB,MAAA;EAAA,SAC7B,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA;AAAA,KAaC,iBAAA;EAAA,SAA+B,KAAA;EAAA,SAAwB,MAAA;AAAA;;;;;;KAevD,uBAAA,IACV,SAAA,UACA,SAAA,aACG,MAAA;AAAA,iBAEW,gBAAA,CACd,KAAA,EAAO,aAAA,EACP,WAAA,GAAc,WAAA,EACd,kBAAA,GAAqB,MAAA,oBACpB,iBAAA;AAAA,iBAkDa,yBAAA,CACd,KAAA,EAAO,aAAA,EACP,WAAA,GAAc,WAAA,EACd,IAAA;AAAA,iBAKc,0BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA,GACxB,iBAAA;AAAA,iBA2Ca,2BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA;AAAA,iBAKX,0BAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,eACvB,WAAA,GAAc,WAAA,EACd,sBAAA,GAAyB,uBAAA;AAAA,iBAKX,uBAAA,CACd,OAAA,UACA,EAAA,EAAI,mBAAA,EACJ,aAAA,EAAe,MAAA,SAAe,mBAAA,GAC9B,IAAA,uBACA,WAAA,GAAc,WAAA;AAAA,iBAKA,sBAAA,CACd,OAAA,UACA,EAAA,EAAI,mBAAA,EACJ,aAAA,EAAe,MAAA,SAAe,mBAAA,GAC9B,WAAA,GAAc,WAAA,GACb,iBAAA;AAAA,iBAgBa,+BAAA,CAAgC,SAAA,UAAmB,KAAA,EAAO,aAAA;AAAA,iBAoB1D,kCAAA,CACd,YAAA,EAAc,MAAA,SAAe,mBAAA;AAAA,iBAoBf,8BAAA,CACd,YAAA,EAAc,MAAA,SAAe,mBAAA,eAC7B,WAAA,GAAc,WAAA"}

package/dist/exports/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/artifact-paths.ts","../../src/emit-types.ts","../../src/emit.ts","../../src/generate-contract-dts.ts"],"mappings":";;;;;;UAEiB,oBAAA;EAAA,SACN,QAAA;EAAA,SACA,OAAA;AAAA;AAAA,iBAGK,uBAAA,CAAwB,cAAA,WAAyB,oBAAA;;;;;;;AALjE;UCMiB,cAAA;EAAA,SACN,gBAAA,GAAmB,aAAA,CAAc,eAAA;EAAA,SACjC,yBAAA,GAA4B,aAAA,CAAc,eAAA;EAAA,SAC1C,YAAA,GAAe,aAAA;EAAA,SACf,WAAA,GAAc,WAAA;AAAA;AAAA,UAGR,WAAA;EAAA,SACN,cAAA;AAAA;AAAA,UAGM,UAAA;EAAA,SACN,YAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA;;;iBCbW,IAAA,CACpB,QAAA,EAAU,QAAA,EACV,KAAA,EAAO,cAAA,EACP,YAAA,EAAc,WAAA,EACd,OAAA,GAAU,WAAA,GACT,OAAA,CAAQ,UAAA;;;iBCKK,mBAAA,CACd,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,WAAA,EACT,gBAAA,EAAkB,aAAA,CAAc,eAAA,GAChC,MAAA;EAAA,SACW,WAAA;EAAA,SACA,aAAA;EAAA,SACA,WAAA;AAAA,GAEX,OAAA,GAAU,4BAAA,EACV,WAAA,GAAc,WAAA"}

package/dist/exports/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/artifact-paths.ts","../../src/generate-contract-dts.ts","../../src/emit.ts"],"sourcesContent":["const JSON_EXTENSION = '.json';\n\nexport interface EmittedArtifactPaths {\n  readonly jsonPath: string;\n  readonly dtsPath: string;\n}\n\nexport function getEmittedArtifactPaths(outputJsonPath: string): EmittedArtifactPaths {\n  if (!outputJsonPath.endsWith(JSON_EXTENSION)) {\n    throw new Error('Contract output path must end with .json');\n  }\n\n  return {\n    jsonPath: outputJsonPath,\n    dtsPath: `${outputJsonPath.slice(0, -JSON_EXTENSION.length)}.d.ts`,\n  };\n}\n","import type { Contract, ContractModel, ContractValueObject } from '@prisma-next/contract/types';\nimport type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport type {\n  EmissionSpi,\n  GenerateContractTypesOptions,\n  TypesImportSpec,\n} from '@prisma-next/framework-components/emission';\nimport {\n  deduplicateImports,\n  generateBothFieldTypesMaps,\n  generateCodecTypeIntersection,\n  generateHashTypeAliases,\n  generateImportLines,\n  generateModelsType,\n  generateRootsType,\n  generateValueObjectsDescriptorType,\n  generateValueObjectTypeAliases,\n  serializeExecutionType,\n  serializeValue,\n} from './domain-type-generation';\n\nexport function generateContractDts(\n  contract: Contract,\n  emitter: EmissionSpi,\n  codecTypeImports: ReadonlyArray<TypesImportSpec>,\n  hashes: {\n    readonly storageHash: string;\n    readonly executionHash?: string;\n    readonly profileHash: string;\n  },\n  options?: GenerateContractTypesOptions,\n  codecLookup?: CodecLookup,\n): string {\n  const allImports: TypesImportSpec[] = [...codecTypeImports];\n  if (options?.queryOperationTypeImports) {\n    allImports.push(...options.queryOperationTypeImports);\n  }\n  const uniqueImports = deduplicateImports(allImports);\n  const importLines = generateImportLines(uniqueImports);\n\n  const familyImportLines = emitter.getFamilyImports();\n\n  const hashAliases = generateHashTypeAliases(hashes);\n\n  const codecTypes = generateCodecTypeIntersection(codecTypeImports, 'CodecTypes');\n\n  const familyTypeAliases = emitter.getFamilyTypeAliases(options);\n\n  const typeMapsExpr = emitter.getTypeMapsExpression();\n\n  const storageType = emitter.generateStorageType(contract, 'StorageHash');\n\n  const modelsType = generateModelsType(\n    contract.models as Record<string, ContractModel>,\n    (name, model) => emitter.generateModelStorageType(name, model),\n  );\n\n  const rootsType = generateRootsType(contract.roots);\n\n  const valueObjects = contract.valueObjects as Record<string, ContractValueObject> | undefined;\n  const valueObjectTypeAliases = generateValueObjectTypeAliases(valueObjects, codecLookup);\n  const valueObjectsDescriptor = generateValueObjectsDescriptorType(valueObjects);\n\n  const executionClause =\n    contract.execution !== undefined\n      ? `\\n  readonly execution: ${serializeExecutionType(contract.execution)};`\n      : '';\n\n  const resolveFieldTypeParams = emitter.resolveFieldTypeParams\n    ? (modelName: string, fieldName: string) => {\n        const model = (contract.models as Record<string, ContractModel> | undefined)?.[modelName];\n        if (!model) return undefined;\n        return emitter.resolveFieldTypeParams?.(modelName, fieldName, model, contract);\n      }\n    : undefined;\n\n  const fieldTypesMaps = generateBothFieldTypesMaps(\n    contract.models as Record<string, ContractModel> | undefined,\n    codecLookup,\n    resolveFieldTypeParams,\n  );\n\n  const contractWrapper = emitter.getContractWrapper('ContractBase', 'TypeMaps');\n\n  return `// ⚠️  GENERATED FILE - DO NOT EDIT\n// This file is automatically generated by 'prisma-next contract emit'.\n// To regenerate, run: prisma-next contract emit\n${importLines.join('\\n')}\n\n${familyImportLines.join('\\n')}\nimport type {\n  Contract as ContractType,\n  ExecutionHashBase,\n  ProfileHashBase,\n  StorageHashBase,\n} from '@prisma-next/contract/types';\n\n${hashAliases}\n\nexport type CodecTypes = ${codecTypes};\n${familyTypeAliases}\n${valueObjectTypeAliases}\nexport type FieldOutputTypes = ${fieldTypesMaps.output};\nexport type FieldInputTypes = ${fieldTypesMaps.input};\nexport type TypeMaps = ${typeMapsExpr};\n\ntype ContractBase = ContractType<\n${storageType},\n${modelsType}\n> & {\n  readonly target: ${serializeValue(contract.target)};\n  readonly targetFamily: ${serializeValue(contract.targetFamily)};\n  readonly roots: ${rootsType};\n  readonly capabilities: ${serializeValue(contract.capabilities)};\n  readonly extensionPacks: ${serializeValue(contract.extensionPacks)};${executionClause}\n  readonly meta: ${serializeValue(contract.meta)};\n  ${valueObjects ? `readonly valueObjects: ${valueObjectsDescriptor};` : ''}\n  readonly profileHash: ProfileHash;\n};\n\n${contractWrapper}\n`;\n}\n","import { canonicalizeContractToObject } from '@prisma-next/contract/hashing';\nimport type { Contract } from '@prisma-next/contract/types';\nimport type { EmissionSpi } from '@prisma-next/framework-components/emission';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { format } from 'prettier';\nimport { getEmittedArtifactPaths } from './artifact-paths';\nimport type { EmitOptions, EmitResult, EmitStackInput } from './emit-types';\nimport { generateContractDts } from './generate-contract-dts';\n\nconst SCHEMA_VERSION = '1';\n\nexport async function emit(\n  contract: Contract,\n  stack: EmitStackInput,\n  targetFamily: EmissionSpi,\n  options?: EmitOptions,\n): Promise<EmitResult> {\n  if (options?.outputJsonPath !== undefined) {\n    getEmittedArtifactPaths(options.outputJsonPath);\n  }\n\n  const { codecTypeImports, queryOperationTypeImports } = stack;\n\n  const { storageHash } = contract.storage;\n  const executionHash = contract.execution?.executionHash;\n  const { profileHash } = contract;\n\n  const canonicalized = canonicalizeContractToObject(contract, {\n    schemaVersion: SCHEMA_VERSION,\n  });\n  const contractJsonString = JSON.stringify(\n    {\n      ...canonicalized,\n      _generated: {\n        warning: '⚠️  GENERATED FILE - DO NOT EDIT',\n        message: 'This file is automatically generated by \"prisma-next contract emit\".',\n        regenerate: 'To regenerate, run: prisma-next contract emit',\n      },\n    },\n    null,\n    2,\n  );\n\n  const generateOptions = queryOperationTypeImports ? { queryOperationTypeImports } : undefined;\n\n  const contractTypeHashes = {\n    storageHash,\n    ...ifDefined('executionHash', executionHash),\n    profileHash,\n  };\n  const contractDtsRaw = generateContractDts(\n    contract,\n    targetFamily,\n    codecTypeImports ?? [],\n    contractTypeHashes,\n    generateOptions,\n    stack.codecLookup,\n  );\n  const contractDts = await format(contractDtsRaw, {\n    parser: 'typescript',\n    singleQuote: true,\n    semi: true,\n    printWidth: 100,\n  });\n\n  return {\n    contractJson: contractJsonString,\n    contractDts,\n    storageHash,\n    ...ifDefined('executionHash', executionHash),\n    profileHash,\n  };\n}\n"],"mappings":"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"}