@prisma-next/mongo-contract-psl 0.13.0 → 0.14.0-dev.10

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

@@ -1 +1 @@
-{"version":3,"file":"provider.d.mts","names":[],"sources":["../../src/provider.ts"],"mappings":";;;UAOiB,oBAAA;EAAA,SACN,MAAM;AAAA;AAAA,iBAGD,aAAA,CAAc,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,cAAc"}
+{"version":3,"file":"provider.d.mts","names":[],"sources":["../../src/provider.ts"],"mappings":";;;UAUiB,oBAAA;EAAA,SACN,MAAM;AAAA;AAAA,iBAgBD,aAAA,CAAc,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,cAAc"}

package/dist/exports/provider.mjs

@@ -1,12 +1,22 @@
-import { t as interpretPslDocumentToMongoContract } from "../interpreter-CNVgUGau.mjs";
+import { t as interpretPslDocumentToMongoContract } from "../interpreter-DCiVHDlW.mjs";
+import { buildSymbolTable, rangeToPslSpan } from "@prisma-next/psl-parser";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { parsePslDocument } from "@prisma-next/psl-parser";
-import { readFile } from "node:fs/promises";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { readFile } from "node:fs/promises";
+import { parse } from "@prisma-next/psl-parser/syntax";
 //#region src/provider.ts
+function mapParseDiagnostics(diagnostics, sourceFile, sourceId) {
+	return diagnostics.map((diagnostic) => ({
+		code: diagnostic.code,
+		message: diagnostic.message,
+		sourceId,
+		span: rangeToPslSpan(diagnostic.range, sourceFile)
+	}));
+}
 function mongoContract(schemaPath, options) {
 	return {
 		source: {
+			sourceFormat: "psl",
 			inputs: [schemaPath],
 			load: async (context) => {
 				const [absoluteSchemaPath] = context.resolvedInputs;
@@ -30,11 +40,18 @@ function mongoContract(schemaPath, options) {
 						}
 					});
 				}
+				const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);
+				const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({
+					document,
+					sourceFile,
+					scalarTypes: [...context.scalarTypeDescriptors.keys()],
+					pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors
+				});
 				const interpreted = interpretPslDocumentToMongoContract({
-					document: parsePslDocument({
-						schema,
-						sourceId: schemaPath
-					}),
+					symbolTable,
+					sourceFile,
+					sourceId: schemaPath,
+					seedDiagnostics: [...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath), ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath)],
 					scalarTypeDescriptors: context.scalarTypeDescriptors,
 					codecLookup: context.codecLookup
 				});

package/dist/exports/provider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"provider.mjs","names":[],"sources":["../../src/provider.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport type { ContractConfig } from '@prisma-next/config/config-types';\nimport { parsePslDocument } from '@prisma-next/psl-parser';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { interpretPslDocumentToMongoContract } from './interpreter';\n\nexport interface MongoContractOptions {\n  readonly output?: string;\n}\n\nexport function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig {\n  return {\n    source: {\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'mongoContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        let schema: string;\n        try {\n          schema = await readFile(absoluteSchemaPath, 'utf-8');\n        } catch (error) {\n          const message = String(error);\n          return notOk({\n            summary: `Failed to read Prisma schema at \"${schemaPath}\"`,\n            diagnostics: [\n              {\n                code: 'PSL_SCHEMA_READ_FAILED',\n                message,\n                sourceId: schemaPath,\n              },\n            ],\n            meta: { schemaPath, absoluteSchemaPath, cause: message },\n          });\n        }\n\n        const document = parsePslDocument({\n          schema,\n          sourceId: schemaPath,\n        });\n\n        const interpreted = interpretPslDocumentToMongoContract({\n          document,\n          scalarTypeDescriptors: context.scalarTypeDescriptors,\n          codecLookup: context.codecLookup,\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(interpreted.value);\n      },\n    },\n    ...ifDefined('output', options?.output),\n  };\n}\n"],"mappings":";;;;;;AAWA,SAAgB,cAAc,YAAoB,SAAgD;CAChG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,iIACF;IAEF,IAAI;IACJ,IAAI;KACF,SAAS,MAAM,SAAS,oBAAoB,OAAO;IACrD,SAAS,OAAO;KACd,MAAM,UAAU,OAAO,KAAK;KAC5B,OAAO,MAAM;MACX,SAAS,oCAAoC,WAAW;MACxD,aAAa,CACX;OACE,MAAM;OACN;OACA,UAAU;MACZ,CACF;MACA,MAAM;OAAE;OAAY;OAAoB,OAAO;MAAQ;KACzD,CAAC;IACH;IAOA,MAAM,cAAc,oCAAoC;KACtD,UANe,iBAAiB;MAChC;MACA,UAAU;KACZ,CAGS;KACP,uBAAuB,QAAQ;KAC/B,aAAa,QAAQ;IACvB,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GAAG,YAAY,KAAK;GAC7B;EACF;EACA,GAAG,UAAU,UAAU,SAAS,MAAM;CACxC;AACF"}
+{"version":3,"file":"provider.mjs","names":[],"sources":["../../src/provider.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport type { ContractConfig, ContractSourceDiagnostic } from '@prisma-next/config/config-types';\nimport { buildSymbolTable, rangeToPslSpan } from '@prisma-next/psl-parser';\nimport type { ParseDiagnostic, SourceFile } from '@prisma-next/psl-parser/syntax';\nimport { parse } from '@prisma-next/psl-parser/syntax';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\n\nimport { interpretPslDocumentToMongoContract } from './interpreter';\n\nexport interface MongoContractOptions {\n  readonly output?: string;\n}\n\nfunction mapParseDiagnostics(\n  diagnostics: readonly ParseDiagnostic[],\n  sourceFile: SourceFile,\n  sourceId: string,\n): ContractSourceDiagnostic[] {\n  return diagnostics.map((diagnostic) => ({\n    code: diagnostic.code,\n    message: diagnostic.message,\n    sourceId,\n    span: rangeToPslSpan(diagnostic.range, sourceFile),\n  }));\n}\n\nexport function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig {\n  return {\n    source: {\n      sourceFormat: 'psl',\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'mongoContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        let schema: string;\n        try {\n          schema = await readFile(absoluteSchemaPath, 'utf-8');\n        } catch (error) {\n          const message = String(error);\n          return notOk({\n            summary: `Failed to read Prisma schema at \"${schemaPath}\"`,\n            diagnostics: [\n              {\n                code: 'PSL_SCHEMA_READ_FAILED',\n                message,\n                sourceId: schemaPath,\n              },\n            ],\n            meta: { schemaPath, absoluteSchemaPath, cause: message },\n          });\n        }\n\n        const { document, sourceFile, diagnostics: parseDiagnostics } = parse(schema);\n        const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({\n          document,\n          sourceFile,\n          scalarTypes: [...context.scalarTypeDescriptors.keys()],\n          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,\n        });\n\n        // Do not short-circuit on provider-level diagnostics; recovered CST can\n        // still produce interpreter diagnostics in the same response.\n        const seedDiagnostics = [\n          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),\n          ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath),\n        ];\n\n        const interpreted = interpretPslDocumentToMongoContract({\n          symbolTable,\n          sourceFile,\n          sourceId: schemaPath,\n          seedDiagnostics,\n          scalarTypeDescriptors: context.scalarTypeDescriptors,\n          codecLookup: context.codecLookup,\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(interpreted.value);\n      },\n    },\n    ...ifDefined('output', options?.output),\n  };\n}\n"],"mappings":";;;;;;;AAcA,SAAS,oBACP,aACA,YACA,UAC4B;CAC5B,OAAO,YAAY,KAAK,gBAAgB;EACtC,MAAM,WAAW;EACjB,SAAS,WAAW;EACpB;EACA,MAAM,eAAe,WAAW,OAAO,UAAU;CACnD,EAAE;AACJ;AAEA,SAAgB,cAAc,YAAoB,SAAgD;CAChG,OAAO;EACL,QAAQ;GACN,cAAc;GACd,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,iIACF;IAEF,IAAI;IACJ,IAAI;KACF,SAAS,MAAM,SAAS,oBAAoB,OAAO;IACrD,SAAS,OAAO;KACd,MAAM,UAAU,OAAO,KAAK;KAC5B,OAAO,MAAM;MACX,SAAS,oCAAoC,WAAW;MACxD,aAAa,CACX;OACE,MAAM;OACN;OACA,UAAU;MACZ,CACF;MACA,MAAM;OAAE;OAAY;OAAoB,OAAO;MAAQ;KACzD,CAAC;IACH;IAEA,MAAM,EAAE,UAAU,YAAY,aAAa,qBAAqB,MAAM,MAAM;IAC5E,MAAM,EAAE,OAAO,aAAa,aAAa,2BAA2B,iBAAiB;KACnF;KACA;KACA,aAAa,CAAC,GAAG,QAAQ,sBAAsB,KAAK,CAAC;KACrD,qBAAqB,QAAQ,uBAAuB;IACtD,CAAC;IASD,MAAM,cAAc,oCAAoC;KACtD;KACA;KACA,UAAU;KACV,iBAAA,CARA,GAAG,oBAAoB,kBAAkB,YAAY,UAAU,GAC/D,GAAG,oBAAoB,wBAAwB,YAAY,UAAU,CAOvD;KACd,uBAAuB,QAAQ;KAC/B,aAAa,QAAQ;IACvB,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GAAG,YAAY,KAAK;GAC7B;EACF;EACA,GAAG,UAAU,UAAU,SAAS,MAAM;CACxC;AACF"}

package/dist/index.d.mts

@@ -1,14 +1,18 @@
 import { Contract } from "@prisma-next/contract/types";
+import { SymbolTable } from "@prisma-next/psl-parser";
 import { Result } from "@prisma-next/utils/result";
-import { ParsePslDocumentResult } from "@prisma-next/psl-parser";
-import { ContractSourceDiagnostics } from "@prisma-next/config/config-types";
+import { SourceFile } from "@prisma-next/psl-parser/syntax";
+import { ContractSourceDiagnostic, ContractSourceDiagnostics } from "@prisma-next/config/config-types";
 import { CodecLookup } from "@prisma-next/framework-components/codec";
 
 //#region src/interpreter.d.ts
 interface InterpretPslDocumentToMongoContractInput {
-  readonly document: ParsePslDocumentResult;
+  readonly symbolTable: SymbolTable;
+  readonly sourceFile: SourceFile;
+  readonly sourceId: string;
   readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
   readonly codecLookup?: CodecLookup;
+  readonly seedDiagnostics?: readonly ContractSourceDiagnostic[];
 }
 declare function interpretPslDocumentToMongoContract(input: InterpretPslDocumentToMongoContractInput): Result<Contract, ContractSourceDiagnostics>;
 //#endregion

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/interpreter.ts"],"mappings":";;;;;;;UA4CiB,wCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,qBAAA,EAAuB,WAAA;EAAA,SACvB,WAAA,GAAc,WAAA;AAAA;AAAA,iBAiyBT,mCAAA,CACd,KAAA,EAAO,wCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/interpreter.ts"],"mappings":";;;;;;;;UAkDiB,wCAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,UAAA,EAAY,UAAA;EAAA,SACZ,QAAA;EAAA,SACA,qBAAA,EAAuB,WAAA;EAAA,SACvB,WAAA,GAAc,WAAA;EAAA,SACd,eAAA,YAA2B,wBAAA;AAAA;AAAA,iBAoxBtB,mCAAA,CACd,KAAA,EAAO,wCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToMongoContract } from "./interpreter-CNVgUGau.mjs";
+import { t as interpretPslDocumentToMongoContract } from "./interpreter-DCiVHDlW.mjs";
 export { interpretPslDocumentToMongoContract };

package/dist/{interpreter-CNVgUGau.mjs → interpreter-DCiVHDlW.mjs}

@@ -1,10 +1,12 @@
 import { computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
 import { crossRef } from "@prisma-next/contract/types";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { MongoCollection, MongoIndex, MongoStorage, MongoValidator, applyPolymorphicScopeToMongoIndex, buildMongoNamespace } from "@prisma-next/mongo-contract";
+import { MongoIndex, MongoStorage, MongoValidator, applyPolymorphicScopeToMongoIndex, buildMongoNamespace } from "@prisma-next/mongo-contract";
 import { mongoContractCanonicalizationHooks } from "@prisma-next/mongo-contract/canonicalization-hooks";
+import { nodePslSpan, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
+import { blindCast } from "@prisma-next/utils/casts";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
+import { ifDefined } from "@prisma-next/utils/defined";
 //#region src/derive-json-schema.ts
 function resolveBsonType(codecId, codecLookup) {
 	return codecLookup?.targetTypesFor(codecId)?.[0];
@@ -98,6 +100,9 @@ function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, v
 }
 //#endregion
 //#region src/psl-helpers.ts
+function getPositionalArgument(attr, index = 0) {
+	return attr.args.filter((arg) => arg.kind === "positional")[index]?.value;
+}
 function getNamedArgument(attr, name) {
 	return attr.args.find((a) => a.kind === "named" && a.name === name)?.value;
 }
@@ -172,9 +177,9 @@ function parseRelationAttribute(attributes) {
 	const fields = fieldsArg ? parseFieldList(fieldsArg.value) : void 0;
 	const references = referencesArg ? parseFieldList(referencesArg.value) : void 0;
 	return {
-		...relationName !== void 0 ? { relationName } : {},
-		...fields !== void 0 ? { fields } : {},
-		...references !== void 0 ? { references } : {}
+		...ifDefined("relationName", relationName),
+		...ifDefined("fields", fields),
+		...ifDefined("references", references)
 	};
 }
 function stripQuotes(value) {
@@ -184,37 +189,23 @@ function stripQuotes(value) {
 //#endregion
 //#region src/interpreter.ts
 /**
-* Name of the framework-parser synthesised bucket for top-level
-* declarations. Re-declared locally so the interpreter does not have to
-* import from `@prisma-next/framework-components/psl-ast`.
-*/
-const UNSPECIFIED_PSL_NAMESPACE_NAME = "__unspecified__";
-/**
-* Mongo FR16c validation: Mongo's authoring DSL exposes the connection's
-* database as the only namespace surface today, so the PSL interpreter
-* rejects every explicit `namespace { … }` block. The implicit
-* `__unspecified__` bucket (top-level declarations) is the only
-* namespace Mongo accepts. `namespace unbound { … }` is rejected too —
-* Mongo has no late-binding namespace concept on the PSL surface (the
-* database name comes from the connection string, not from PSL).
+* Mongo's PSL surface binds the database from the connection string, so every
+* explicit namespace block is invalid, including `namespace unbound { … }`.
 */
 function validateNamespaceBlocksForMongoTarget(input) {
-	for (const namespace of input.namespaces) {
-		if (namespace.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
-		input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
-			message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
-			sourceId: input.sourceId,
-			span: namespace.span
-		});
-	}
+	for (const namespace of input.namespaces) input.diagnostics.push({
+		code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+		message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
+		sourceId: input.sourceId,
+		span: nodePslSpan(namespace.node.syntax, input.sourceFile)
+	});
 }
 function fkRelationPairKey(declaringModel, targetModel) {
 	return `${declaringModel}::${targetModel}`;
 }
 function resolveFieldMappings(model) {
 	const pslNameToMapped = /* @__PURE__ */ new Map();
-	for (const field of model.fields) {
+	for (const field of Object.values(model.fields)) {
 		const mapped = getMapName(field.attributes) ?? field.name;
 		pslNameToMapped.set(field.name, mapped);
 	}
@@ -226,33 +217,32 @@ function resolveCollectionName(model) {
 function mongoCrossRef(modelName) {
 	return crossRef(modelName, UNBOUND_NAMESPACE_ID);
 }
-function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
+function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
-	const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
-	for (const pslModel of allPslModels) for (const attr of pslModel.attributes) {
+	for (const model of models) for (const attr of model.attributes) {
 		if (attr.name === "discriminator") {
 			const fieldName = getPositionalArgument(attr);
 			if (!fieldName) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@discriminator requires a field name argument`,
+					message: `Model "${model.name}" @@discriminator requires a field name argument`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			const discField = pslModel.fields.find((f) => f.name === fieldName);
+			const discField = model.fields[fieldName];
 			if (discField && discField.typeName !== "String") {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Discriminator field "${fieldName}" on model "${pslModel.name}" must be of type String, but is "${discField.typeName}"`,
+					message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			discriminatorDeclarations.set(pslModel.name, {
+			discriminatorDeclarations.set(model.name, {
 				fieldName,
 				span: attr.span
 			});
@@ -263,7 +253,7 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 			if (!baseName || !rawValue) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@base requires two arguments: base model name and discriminator value`,
+					message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
 					sourceId,
 					span: attr.span
 				});
@@ -273,14 +263,14 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 			if (value === void 0) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@base discriminator value must be a quoted string literal`,
+					message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			const collectionName = resolveCollectionName(pslModel);
-			baseDeclarations.set(pslModel.name, {
+			const collectionName = resolveCollectionName(model);
+			baseDeclarations.set(model.name, {
 				baseName,
 				value,
 				collectionName,
@@ -294,8 +284,7 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 	};
 }
 function resolvePolymorphism(input) {
-	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, document, indexSpans, modelIndexesByName } = input;
-	const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
+	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, allModels: allModelViews, indexSpans, modelIndexesByName } = input;
 	let patched = input.models;
 	let roots = input.roots;
 	let collections = input.collections;
@@ -312,8 +301,8 @@ function resolvePolymorphism(input) {
 		}
 		const model = patched[modelName];
 		if (!model) continue;
-		const pslModel = allPslModels.find((m) => m.name === modelName);
-		const mappedDiscriminatorField = pslModel ? resolveFieldMappings(pslModel).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName : decl.fieldName;
+		const modelView = allModelViews.find((m) => m.name === modelName);
+		const mappedDiscriminatorField = modelView ? resolveFieldMappings(modelView).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName : decl.fieldName;
 		if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
@@ -367,9 +356,9 @@ function resolvePolymorphism(input) {
 		}
 		if (discriminatorDeclarations.has(variantName)) continue;
 		const baseModel = patched[baseDecl.baseName];
-		const variantPslModel = allPslModels.find((m) => m.name === variantName);
-		if (!variantPslModel) continue;
-		if (getMapName(variantPslModel.attributes) !== void 0 && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
+		const variantModelView = allModelViews.find((m) => m.name === variantName);
+		if (!variantModelView) continue;
+		if (getMapName(variantModelView.attributes) !== void 0 && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
 			diagnostics.push({
 				code: "PSL_MONGO_VARIANT_SEPARATE_COLLECTION",
 				message: `Mongo variant "${variantName}" cannot use a different collection than its base "${baseDecl.baseName}". Mongo only supports single-collection polymorphism.`,
@@ -388,7 +377,7 @@ function resolvePolymorphism(input) {
 				storage: { collection: baseCollection }
 			}
 		};
-		const variantCollectionName = resolveCollectionName(variantPslModel);
+		const variantCollectionName = resolveCollectionName(variantModelView);
 		if (roots[variantCollectionName]?.model === variantName) if (variantCollectionName === baseCollection && baseModel) roots = {
 			...roots,
 			[variantCollectionName]: mongoCrossRef(baseDecl.baseName)
@@ -496,21 +485,21 @@ function parseCollation(attr) {
 	if (!locale) return getNamedArgument(attr, "collationStrength") != null || getNamedArgument(attr, "collationCaseLevel") != null || getNamedArgument(attr, "collationCaseFirst") != null || getNamedArgument(attr, "collationNumericOrdering") != null || getNamedArgument(attr, "collationAlternate") != null || getNamedArgument(attr, "collationMaxVariable") != null || getNamedArgument(attr, "collationBackwards") != null || getNamedArgument(attr, "collationNormalization") != null ? null : void 0;
 	const collation = { locale };
 	const strength = parseNumericArg(getNamedArgument(attr, "collationStrength"));
-	if (strength != null) collation["strength"] = strength;
+	if (strength != null) collation.strength = strength;
 	const caseLevel = parseBooleanArg(getNamedArgument(attr, "collationCaseLevel"));
-	if (caseLevel != null) collation["caseLevel"] = caseLevel;
+	if (caseLevel != null) collation.caseLevel = caseLevel;
 	const caseFirst = stripQuotesHelper(getNamedArgument(attr, "collationCaseFirst"));
-	if (caseFirst != null) collation["caseFirst"] = caseFirst;
+	if (caseFirst != null) collation.caseFirst = caseFirst;
 	const numericOrdering = parseBooleanArg(getNamedArgument(attr, "collationNumericOrdering"));
-	if (numericOrdering != null) collation["numericOrdering"] = numericOrdering;
+	if (numericOrdering != null) collation.numericOrdering = numericOrdering;
 	const alternate = stripQuotesHelper(getNamedArgument(attr, "collationAlternate"));
-	if (alternate != null) collation["alternate"] = alternate;
+	if (alternate != null) collation.alternate = alternate;
 	const maxVariable = stripQuotesHelper(getNamedArgument(attr, "collationMaxVariable"));
-	if (maxVariable != null) collation["maxVariable"] = maxVariable;
+	if (maxVariable != null) collation.maxVariable = maxVariable;
 	const backwards = parseBooleanArg(getNamedArgument(attr, "collationBackwards"));
-	if (backwards != null) collation["backwards"] = backwards;
+	if (backwards != null) collation.backwards = backwards;
 	const normalization = parseBooleanArg(getNamedArgument(attr, "collationNormalization"));
-	if (normalization != null) collation["normalization"] = normalization;
+	if (normalization != null) collation.normalization = normalization;
 	return collation;
 }
 function stripQuotesHelper(raw) {
@@ -530,11 +519,11 @@ function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnosti
 	const indexes = [];
 	let textIndexCount = 0;
 	const indexableFieldNames = /* @__PURE__ */ new Set();
-	for (const f of pslModel.fields) {
+	for (const f of Object.values(pslModel.fields)) {
 		if (modelNames.has(f.typeName)) continue;
 		indexableFieldNames.add(f.name);
 	}
-	for (const field of pslModel.fields) {
+	for (const field of Object.values(pslModel.fields)) {
 		if (modelNames.has(field.typeName)) continue;
 		const uniqueAttr = getAttribute(field.attributes, "unique");
 		if (!uniqueAttr) continue;
@@ -742,6 +731,7 @@ function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTyp
 			many: true
 		} : result;
 	}
+	if (field.malformedType) return;
 	const codecId = resolveFieldCodecId(field, scalarTypeDescriptors);
 	if (!codecId) {
 		diagnostics.push({
@@ -765,16 +755,18 @@ function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTyp
 	} : result;
 }
 function interpretPslDocumentToMongoContract(input) {
-	const { document, scalarTypeDescriptors, codecLookup } = input;
-	const sourceId = document.ast.sourceId;
-	const diagnostics = [];
+	const { symbolTable, sourceFile, scalarTypeDescriptors, codecLookup } = input;
+	const sourceId = input.sourceId;
+	const diagnostics = [...input.seedDiagnostics ?? []];
+	const topLevel = symbolTable.topLevel;
 	validateNamespaceBlocksForMongoTarget({
-		namespaces: document.ast.namespaces,
+		namespaces: Object.values(topLevel.namespaces),
 		sourceId,
+		sourceFile,
 		diagnostics
 	});
-	const allModels = document.ast.namespaces.flatMap((ns) => ns.models);
-	const allCompositeTypes = document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
+	const allModels = Object.values(topLevel.models);
+	const allCompositeTypes = Object.values(topLevel.compositeTypes);
 	const modelNames = new Set(allModels.map((m) => m.name));
 	const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
 	const models = {};
@@ -789,7 +781,7 @@ function interpretPslDocumentToMongoContract(input) {
 		const fieldMappings = resolveFieldMappings(pslModel);
 		const fields = {};
 		const relations = {};
-		for (const field of pslModel.fields) {
+		for (const field of Object.values(pslModel.fields)) {
 			if (isRelationField(field, modelNames)) {
 				const relation = parseRelationAttribute(field.attributes);
 				if (field.list || !(relation?.fields && relation?.references)) {
@@ -833,7 +825,7 @@ function interpretPslDocumentToMongoContract(input) {
 			fields[mappedName] = resolved;
 		}
 		const isVariantModel = pslModel.attributes.some((attr) => attr.name === "base");
-		const hasIdField = pslModel.fields.some((f) => getAttribute(f.attributes, "id") !== void 0);
+		const hasIdField = Object.values(pslModel.fields).some((f) => getAttribute(f.attributes, "id") !== void 0);
 		if (!isVariantModel) if (!hasIdField) diagnostics.push({
 			code: "PSL_MISSING_ID_FIELD",
 			message: `Model "${pslModel.name}" has no field with @id attribute. Every model must have exactly one @id field.`,
@@ -863,7 +855,7 @@ function interpretPslDocumentToMongoContract(input) {
 	const valueObjects = {};
 	for (const compositeType of allCompositeTypes) {
 		const fields = {};
-		for (const field of compositeType.fields) {
+		for (const field of Object.values(compositeType.fields)) {
 			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeDescriptors, sourceId, diagnostics);
 			if (!resolved) continue;
 			fields[field.name] = resolved;
@@ -912,12 +904,12 @@ function interpretPslDocumentToMongoContract(input) {
 			}
 		};
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(document, sourceId, diagnostics);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, sourceId, diagnostics);
 	const polyResult = resolvePolymorphism({
 		models,
 		roots,
 		collections,
-		document,
+		allModels,
 		discriminatorDeclarations,
 		baseDeclarations,
 		modelNames,
@@ -945,28 +937,29 @@ function interpretPslDocumentToMongoContract(input) {
 	}
 	const target = "mongo";
 	const targetFamily = "mongo";
-	const collectionsAsClasses = {};
+	const collectionInputs = {};
 	for (const [name, coll] of Object.entries(resolvedCollections)) {
-		const input = {};
-		if (coll["indexes"] !== void 0) input.indexes = coll["indexes"];
-		if (coll["validator"] !== void 0) input.validator = coll["validator"];
-		if (coll["options"] !== void 0) input.options = coll["options"];
-		collectionsAsClasses[name] = new MongoCollection(input);
+		const raw = {};
+		if (coll["indexes"] != null) raw["indexes"] = coll["indexes"];
+		if (coll["validator"] != null) raw["validator"] = coll["validator"];
+		if (coll["options"] != null) raw["options"] = coll["options"];
+		collectionInputs[name] = blindCast(raw);
 	}
+	const unboundNamespace = buildMongoNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: { collection: collectionInputs }
+	});
 	const storage = new MongoStorage({
 		storageHash: computeStorageHash({
 			target,
 			targetFamily,
 			storage: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
 				id: UNBOUND_NAMESPACE_ID,
-				entries: { collection: collectionsAsClasses }
+				entries: { collection: unboundNamespace.entries.collection }
 			} } },
 			...mongoContractCanonicalizationHooks
 		}),
-		namespaces: { [UNBOUND_NAMESPACE_ID]: buildMongoNamespace({
-			id: UNBOUND_NAMESPACE_ID,
-			entries: { collection: collectionsAsClasses }
-		}) }
+		namespaces: { [UNBOUND_NAMESPACE_ID]: unboundNamespace }
 	});
 	const capabilities = {};
 	return ok({
@@ -991,4 +984,4 @@ function interpretPslDocumentToMongoContract(input) {
 //#endregion
 export { interpretPslDocumentToMongoContract as t };
 
-//# sourceMappingURL=interpreter-CNVgUGau.mjs.map
+//# sourceMappingURL=interpreter-DCiVHDlW.mjs.map