@prisma/orm-framework 0.16.0-dev.36

package/dist/psl-parser__interpret.d.mts

@@ -0,0 +1,40 @@
+import { t as Contract } from "./contract-types-CkdMH7F7-9EHXSwbH.mjs";
+import { r as Result } from "./result-Bpupv5vO.mjs";
+import { c as ContractSourceProvider, m as PslContractSourceProvider, n as ContractSourceContext, o as ContractSourceDiagnostics, r as ContractSourceDiagnostic } from "./config-types-W-87vhZ4-BgYaH8YO.mjs";
+import "./config-types-zrHI32Om.mjs";
+import { I as SourceFile, d as DocumentAst } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
+import { f as SymbolTable } from "./symbol-table-CZ7EVCTL-oYQtrmzq.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/interpret.d.mts
+//#region src/interpret.d.ts
+/**
+ * Lets editor tooling that already parses incrementally (e.g. the language
+ * server) hand cached artifacts to the interpreter instead of forcing a
+ * disk re-parse.
+ */
+interface PslInterpretInput {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+  readonly symbolTable: SymbolTable;
+  readonly sourceId: string;
+}
+/**
+ * Declared here — the authoring layer that owns `DocumentAst` / `SourceFile` /
+ * `SymbolTable` — because `@internal/config` (core) cannot name authoring
+ * types. `interpret` must not read disk or `context.resolvedInputs` — those
+ * are load-path concerns.
+ */
+interface PslInterpretCapable extends PslContractSourceProvider {
+  interpret(input: PslInterpretInput, context: ContractSourceContext): Result<Contract, ContractSourceDiagnostics>;
+}
+/**
+ * Merges caller-side diagnostics (e.g. parse / symbol-table findings) into an
+ * interpretation result. The authored headline is deliberately uniform — it
+ * reports how many errors the schema has, never which pipeline stage found
+ * them.
+ */
+declare function withSeedDiagnostics(result: Result<Contract, ContractSourceDiagnostics>, seedDiagnostics: readonly ContractSourceDiagnostic[]): Result<Contract, ContractSourceDiagnostics>;
+/** The single seam that narrows a contract source to the interpret capability. */
+declare function hasPslInterpreter(source: ContractSourceProvider): source is PslInterpretCapable;
+//#endregion
+export { type PslInterpretCapable, type PslInterpretInput, hasPslInterpreter, withSeedDiagnostics };
+//# sourceMappingURL=psl-parser__interpret.d.mts.map

package/dist/psl-parser__interpret.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-parser__interpret.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/interpret.d.mts"],"mappings":";;;;;;;;;;;;;UAWU;WACC,UAAU;WACV,YAAY;WACZ,aAAa;WACb;;;;;;;;UAQD,4BAA4B;EACpC,UAAU,OAAO,mBAAmB,SAAS,wBAAwB,OAAO,UAAU;;;;;;;;iBAQvE,oBAAoB,QAAQ,OAAO,UAAU,4BAA4B,0BAA0B,6BAA6B,OAAO,UAAU;;iBAEjJ,kBAAkB,QAAQ,yBAAyB,UAAU"}

package/dist/psl-parser__interpret.mjs

@@ -0,0 +1,25 @@
+import { t as notOk } from "./result-CBZ8X9mU.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/interpret.mjs
+/**
+* Merges caller-side diagnostics (e.g. parse / symbol-table findings) into an
+* interpretation result. The authored headline is deliberately uniform — it
+* reports how many errors the schema has, never which pipeline stage found
+* them.
+*/
+function withSeedDiagnostics(result, seedDiagnostics) {
+	if (seedDiagnostics.length === 0) return result;
+	const diagnostics = result.ok ? seedDiagnostics : [...seedDiagnostics, ...result.failure.diagnostics];
+	return notOk({
+		summary: `Schema has ${diagnostics.length} error${diagnostics.length === 1 ? "" : "s"}`,
+		diagnostics,
+		...result.ok || result.failure.meta === void 0 ? {} : { meta: result.failure.meta }
+	});
+}
+/** The single seam that narrows a contract source to the interpret capability. */
+function hasPslInterpreter(source) {
+	return source.format === "psl" && "interpret" in source && typeof source.interpret === "function";
+}
+//#endregion
+export { hasPslInterpreter, withSeedDiagnostics };
+
+//# sourceMappingURL=psl-parser__interpret.mjs.map

package/dist/psl-parser__interpret.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-parser__interpret.mjs","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/interpret.mjs"],"sourcesContent":["import { notOk } from \"@internal/utils/result\";\n//#region src/interpret.ts\n/**\n* Merges caller-side diagnostics (e.g. parse / symbol-table findings) into an\n* interpretation result. The authored headline is deliberately uniform — it\n* reports how many errors the schema has, never which pipeline stage found\n* them.\n*/\nfunction withSeedDiagnostics(result, seedDiagnostics) {\n\tif (seedDiagnostics.length === 0) return result;\n\tconst diagnostics = result.ok ? seedDiagnostics : [...seedDiagnostics, ...result.failure.diagnostics];\n\treturn notOk({\n\t\tsummary: `Schema has ${diagnostics.length} error${diagnostics.length === 1 ? \"\" : \"s\"}`,\n\t\tdiagnostics,\n\t\t...result.ok || result.failure.meta === void 0 ? {} : { meta: result.failure.meta }\n\t});\n}\n/** The single seam that narrows a contract source to the interpret capability. */\nfunction hasPslInterpreter(source) {\n\treturn source.format === \"psl\" && \"interpret\" in source && typeof source.interpret === \"function\";\n}\n//#endregion\nexport { hasPslInterpreter, withSeedDiagnostics };\n\n//# sourceMappingURL=interpret.mjs.map"],"mappings":";;;;;;;;AAQA,SAAS,oBAAoB,QAAQ,iBAAiB;CACrD,IAAI,gBAAgB,WAAW,GAAG,OAAO;CACzC,MAAM,cAAc,OAAO,KAAK,kBAAkB,CAAC,GAAG,iBAAiB,GAAG,OAAO,QAAQ,WAAW;CACpG,OAAO,MAAM;EACZ,SAAS,cAAc,YAAY,OAAO,QAAQ,YAAY,WAAW,IAAI,KAAK;EAClF;EACA,GAAG,OAAO,MAAM,OAAO,QAAQ,SAAS,KAAK,IAAI,CAAC,IAAI,EAAE,MAAM,OAAO,QAAQ,KAAK;CACnF,CAAC;AACF;;AAEA,SAAS,kBAAkB,QAAQ;CAClC,OAAO,OAAO,WAAW,SAAS,eAAe,UAAU,OAAO,OAAO,cAAc;AACxF"}

package/dist/psl-parser__syntax.d.mts

@@ -0,0 +1,31 @@
+import { n as TokenKind } from "./tokenizer-DcYI0Xrq-C-nNE9mE.mjs";
+import { $ as parse, A as ObjectLiteralExprAst, B as SyntaxNode, C as ModelAttributeAst, D as NamespaceMemberAst, E as NamespaceDeclarationAst, F as Range, G as any, H as TokenAtOffset, I as SourceFile, J as filterChildren, K as castExpression, L as StringLiteralExprAst, M as ParseResult, N as Position, O as NumberLiteralExprAst, P as QualifiedNameAst, Q as greenToken, R as SyntaxElement, S as KeyValuePairAst, T as NamedTypeDeclarationAst, U as TypeAnnotationAst, V as SyntaxToken, W as TypesBlockAst, X as findFirstChild, Y as findChildToken, Z as greenNode, _ as GenericBlockMemberAst, a as AttributeAst, b as GreenToken, c as BracedBlock, d as DocumentAst, et as printSyntax, f as ExpressionAst, g as GenericBlockDeclarationAst, h as FunctionCallAst, i as AttributeArgListAst, j as ParseDiagnostic, k as ObjectFieldAst, l as CompositeTypeDeclarationAst, m as FieldDeclarationAst, n as AstNode, o as BlockMemberAst, p as FieldAttributeAst, q as createSyntaxTree, r as AttributeArgAst, s as BooleanLiteralExprAst, t as ArrayLiteralAst, u as DeclarationAst, v as GreenElement, w as ModelDeclarationAst, x as IdentifierAst, y as GreenNode, z as SyntaxKind } from "./parse-0ZJjj_2N-WZZ1nlrv.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/syntax.d.mts
+//#region src/syntax/green-builder.d.ts
+declare class GreenNodeBuilder {
+  #private;
+  startNode(kind: SyntaxKind): void;
+  token(kind: TokenKind, text: string): void;
+  finishNode(): GreenNode;
+}
+//#endregion
+//#region src/syntax/navigation.d.ts
+/** Direction of a sibling/token walk. */
+type Direction = 'next' | 'prev';
+/** Whether a token kind is trivia (whitespace, newline, or comment). */
+declare function isTriviaKind(kind: TokenKind): boolean;
+/** Whether a token is trivia. */
+declare function isTrivia(token: SyntaxToken): boolean;
+/**
+ * The first non-trivia token at or beyond `token` in `direction`. Returns
+ * `token` itself when it is already significant.
+ */
+declare function skipTriviaToken(token: SyntaxToken, direction: Direction): SyntaxToken | undefined;
+/**
+ * The nearest sibling of `element` (within the same parent) in `direction` that
+ * is not a trivia token. Nodes are always significant.
+ */
+declare function nonTriviaSibling(element: SyntaxElement, direction: Direction): SyntaxElement | undefined;
+//#endregion
+export { ArrayLiteralAst, type AstNode, AttributeArgAst, AttributeArgListAst, type AttributeAst, type BlockMemberAst, BooleanLiteralExprAst, type BracedBlock, CompositeTypeDeclarationAst, type DeclarationAst, type Direction, DocumentAst, type ExpressionAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, type GenericBlockMemberAst, type GreenElement, type GreenNode, GreenNodeBuilder, type GreenToken, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, type NamespaceMemberAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, type ParseDiagnostic, type ParseResult, type Position, QualifiedNameAst, type Range, SourceFile, StringLiteralExprAst, type SyntaxElement, type SyntaxKind, SyntaxNode, SyntaxToken, TokenAtOffset, TypeAnnotationAst, TypesBlockAst, any, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, isTrivia, isTriviaKind, nonTriviaSibling, parse, printSyntax, skipTriviaToken };
+//# sourceMappingURL=psl-parser__syntax.d.mts.map

package/dist/psl-parser__syntax.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-parser__syntax.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/syntax.d.mts"],"mappings":";;;;cAGc;;EAEZ,UAAU,MAAM;EAChB,MAAM,MAAM,WAAW;EACvB,cAAc;;;;;KAKX;;iBAEY,aAAa,MAAM;;iBAEnB,SAAS,OAAO;;;;;iBAKhB,gBAAgB,OAAO,aAAa,WAAW,YAAY;;;;;iBAK3D,iBAAiB,SAAS,eAAe,WAAW,YAAY"}

package/dist/psl-parser__syntax.mjs

@@ -0,0 +1,43 @@
+import { A as filterChildren, C as SyntaxToken, D as any, E as TypesBlockAst, M as findFirstChild, N as printSyntax, O as castExpression, S as SyntaxNode, T as TypeAnnotationAst, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, b as QualifiedNameAst, c as FieldDeclarationAst, d as IdentifierAst, f as KeyValuePairAst, g as NamespaceDeclarationAst, h as NamedTypeDeclarationAst, i as BooleanLiteralExprAst, j as findChildToken, k as createSyntaxTree, l as FunctionCallAst, m as ModelDeclarationAst, n as AttributeArgAst, o as DocumentAst, p as ModelAttributeAst, r as AttributeArgListAst, s as FieldAttributeAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, v as ObjectFieldAst, w as TokenAtOffset, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-DR6To8_k-BFwkCGeP.mjs";
+import { a as parse, i as greenToken, n as SourceFile, r as greenNode, t as GreenNodeBuilder } from "./parse-GbZGfMUj-BFSrD2AN.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/syntax.mjs
+const TRIVIA_KINDS = /* @__PURE__ */ new Set([
+	"Whitespace",
+	"Newline",
+	"Comment"
+]);
+/** Whether a token kind is trivia (whitespace, newline, or comment). */
+function isTriviaKind(kind) {
+	return TRIVIA_KINDS.has(kind);
+}
+/** Whether a token is trivia. */
+function isTrivia(token) {
+	return isTriviaKind(token.kind);
+}
+/**
+* The first non-trivia token at or beyond `token` in `direction`. Returns
+* `token` itself when it is already significant.
+*/
+function skipTriviaToken(token, direction) {
+	let current = token;
+	while (current !== void 0 && isTrivia(current)) current = direction === "next" ? current.nextToken : current.prevToken;
+	return current;
+}
+/**
+* The nearest sibling of `element` (within the same parent) in `direction` that
+* is not a trivia token. Nodes are always significant.
+*/
+function nonTriviaSibling(element, direction) {
+	let sibling = step(element, direction);
+	while (sibling !== void 0) {
+		if (!(sibling instanceof SyntaxToken) || !isTrivia(sibling)) return sibling;
+		sibling = step(sibling, direction);
+	}
+}
+function step(element, direction) {
+	return direction === "next" ? element.nextSiblingOrToken : element.prevSiblingOrToken;
+}
+//#endregion
+export { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, QualifiedNameAst, SourceFile, StringLiteralExprAst, SyntaxNode, SyntaxToken, TokenAtOffset, TypeAnnotationAst, TypesBlockAst, any, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, isTrivia, isTriviaKind, nonTriviaSibling, parse, printSyntax, skipTriviaToken };
+
+//# sourceMappingURL=psl-parser__syntax.mjs.map

package/dist/psl-parser__syntax.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-parser__syntax.mjs","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/syntax.mjs"],"sourcesContent":["import { A as SyntaxNode, C as QualifiedNameAst, D as findChildToken, E as filterChildren, M as TokenAtOffset, N as createSyntaxTree, O as findFirstChild, S as castExpression, T as any, _ as FunctionCallAst, a as KeyValuePairAst, b as ObjectLiteralExprAst, c as NamespaceDeclarationAst, d as AttributeArgListAst, f as FieldAttributeAst, g as BooleanLiteralExprAst, h as AttributeArgAst, i as GenericBlockDeclarationAst, j as SyntaxToken, k as printSyntax, l as TypesBlockAst, m as ArrayLiteralAst, n as DocumentAst, o as ModelDeclarationAst, p as ModelAttributeAst, r as FieldDeclarationAst, s as NamedTypeDeclarationAst, t as CompositeTypeDeclarationAst, u as TypeAnnotationAst, v as NumberLiteralExprAst, w as IdentifierAst, x as StringLiteralExprAst, y as ObjectFieldAst } from \"./declarations-DR6To8_k.mjs\";\nimport { a as SourceFile, i as greenToken, n as GreenNodeBuilder, r as greenNode, t as parse } from \"./parse-GbZGfMUj.mjs\";\n//#region src/syntax/navigation.ts\nconst TRIVIA_KINDS = /* @__PURE__ */ new Set([\n\t\"Whitespace\",\n\t\"Newline\",\n\t\"Comment\"\n]);\n/** Whether a token kind is trivia (whitespace, newline, or comment). */\nfunction isTriviaKind(kind) {\n\treturn TRIVIA_KINDS.has(kind);\n}\n/** Whether a token is trivia. */\nfunction isTrivia(token) {\n\treturn isTriviaKind(token.kind);\n}\n/**\n* The first non-trivia token at or beyond `token` in `direction`. Returns\n* `token` itself when it is already significant.\n*/\nfunction skipTriviaToken(token, direction) {\n\tlet current = token;\n\twhile (current !== void 0 && isTrivia(current)) current = direction === \"next\" ? current.nextToken : current.prevToken;\n\treturn current;\n}\n/**\n* The nearest sibling of `element` (within the same parent) in `direction` that\n* is not a trivia token. Nodes are always significant.\n*/\nfunction nonTriviaSibling(element, direction) {\n\tlet sibling = step(element, direction);\n\twhile (sibling !== void 0) {\n\t\tif (!(sibling instanceof SyntaxToken) || !isTrivia(sibling)) return sibling;\n\t\tsibling = step(sibling, direction);\n\t}\n}\nfunction step(element, direction) {\n\treturn direction === \"next\" ? element.nextSiblingOrToken : element.prevSiblingOrToken;\n}\n//#endregion\nexport { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, GreenNodeBuilder, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamedTypeDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectFieldAst, ObjectLiteralExprAst, QualifiedNameAst, SourceFile, StringLiteralExprAst, SyntaxNode, SyntaxToken, TokenAtOffset, TypeAnnotationAst, TypesBlockAst, any, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, isTrivia, isTriviaKind, nonTriviaSibling, parse, printSyntax, skipTriviaToken };\n\n//# sourceMappingURL=syntax.mjs.map"],"mappings":";;;AAGA,MAAM,+BAA+B,IAAI,IAAI;CAC5C;CACA;CACA;AACD,CAAC;;AAED,SAAS,aAAa,MAAM;CAC3B,OAAO,aAAa,IAAI,IAAI;AAC7B;;AAEA,SAAS,SAAS,OAAO;CACxB,OAAO,aAAa,MAAM,IAAI;AAC/B;;;;;AAKA,SAAS,gBAAgB,OAAO,WAAW;CAC1C,IAAI,UAAU;CACd,OAAO,YAAY,KAAK,KAAK,SAAS,OAAO,GAAG,UAAU,cAAc,SAAS,QAAQ,YAAY,QAAQ;CAC7G,OAAO;AACR;;;;;AAKA,SAAS,iBAAiB,SAAS,WAAW;CAC7C,IAAI,UAAU,KAAK,SAAS,SAAS;CACrC,OAAO,YAAY,KAAK,GAAG;EAC1B,IAAI,EAAE,mBAAmB,gBAAgB,CAAC,SAAS,OAAO,GAAG,OAAO;EACpE,UAAU,KAAK,SAAS,SAAS;CAClC;AACD;AACA,SAAS,KAAK,SAAS,WAAW;CACjC,OAAO,cAAc,SAAS,QAAQ,qBAAqB,QAAQ;AACpE"}

package/dist/psl-parser__tokenizer.d.mts

@@ -0,0 +1,2 @@
+import { n as TokenKind, r as Tokenizer, t as Token } from "./tokenizer-DcYI0Xrq-C-nNE9mE.mjs";
+export { type Token, type TokenKind, Tokenizer };

package/dist/psl-parser__tokenizer.mjs

@@ -0,0 +1,2 @@
+import { t as Tokenizer } from "./tokenizer-1hAHZzmp-QGPORvmA.mjs";
+export { Tokenizer };

package/dist/psl-printer.d.mts

@@ -0,0 +1,37 @@
+import { c as CodecLookup } from "./codec-types-XJO6eC9U-B_K2q0zm.mjs";
+import { b as AuthoringPslBlockDescriptorNamespace } from "./framework-authoring-7YMP9TwM-C9P-N6_a.mjs";
+import "./authoring-Dd7p6pTS.mjs";
+import "./codec-D3GVAkR_.mjs";
+import { m as PslDocumentAst } from "./psl-ast-Chgi8e4o-rSlBk1UV.mjs";
+import "./psl-ast-BEwO80EH.mjs";
+//#region ../../../1-framework/2-authoring/psl-printer/dist/index.d.mts
+//#region src/print-psl.d.ts
+type PslBlockDescriptorsNamespace = AuthoringPslBlockDescriptorNamespace;
+interface PrintPslOptions {
+  /**
+   * Extension-contributed PSL block descriptors, indexed by user-facing path.
+   * Typically an `AssembledAuthoringContributions.pslBlockDescriptors` namespace
+   * produced by `assembleAuthoringContributions`. Phase 2 of the printer indexes
+   * into this namespace by each extension-contributed AST node's `kind`
+   * discriminator and renders the block generically from the descriptor's
+   * `parameters` map.
+   *
+   * When absent, an AST that contains extension-contributed blocks throws —
+   * silently dropping blocks would lose user-authored content without a
+   * diagnostic. ASTs that contain only framework-parsed blocks print without
+   * any `pslBlockDescriptors` argument, which is what existing call sites do today.
+   */
+  readonly pslBlockDescriptors?: PslBlockDescriptorsNamespace;
+  /**
+   * Codec lookup used to print `value`-kind block parameters. The codec's JSON
+   * medium (`encodeJson`/`decodeJson`) validates and normalizes each value param.
+   * Required alongside `pslBlockDescriptors` when the AST contains `value`-kind
+   * parameters. When absent, the raw PSL literal stored in the AST node is
+   * emitted as-is.
+   */
+  readonly codecLookup?: CodecLookup;
+}
+declare function printPslFromAst(ast: PslDocumentAst, options?: PrintPslOptions): string;
+//#endregion
+export { printPslFromAst as printPsl };
+//# sourceMappingURL=psl-printer.d.mts.map

package/dist/psl-printer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-printer.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-printer/dist/index.d.mts"],"mappings":";;;;;;;;KAIK,+BAA+B;UAC1B;;;;;;;;;;;;;;WAcC,sBAAsB;;;;;;;;WAQtB,cAAc;;iBAER,gBAAgB,KAAK,gBAAgB,UAAU"}

package/dist/psl-printer.mjs

@@ -0,0 +1,393 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { t as ifDefined } from "./defined-BQWA85QH-BRSBMULx.mjs";
+import { a as structuredError } from "./structured-error-H6WU9Kjt.mjs";
+import { h as isAuthoringPslBlockDescriptor } from "./framework-authoring-CDEvlouU-mlMWSksD.mjs";
+import { i as flatPslModels, s as namespacePslExtensionBlocks } from "./psl-ast-DUCvVXbB.mjs";
+//#region ../../../1-framework/2-authoring/psl-printer/dist/index.mjs
+function contractError(code, message, options) {
+	return structuredError(code, message, options);
+}
+/**
+* Indent unit used for PSL block bodies and namespace nesting.
+*/
+const PSL_INDENT_UNIT = "  ";
+function buildPslBlockDispatchMap(namespace) {
+	const byKeyword = /* @__PURE__ */ new Map();
+	if (namespace) collectBlockDescriptors(namespace, byKeyword);
+	return { byKeyword };
+}
+function collectBlockDescriptors(namespace, byKeyword) {
+	for (const value of Object.values(namespace)) {
+		if (isAuthoringPslBlockDescriptor(value)) {
+			byKeyword.set(value.keyword, value);
+			continue;
+		}
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) collectBlockDescriptors(value, byKeyword);
+	}
+}
+function escapePslString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+}
+function serializePrintDocument(doc, options = {}) {
+	const sections = [];
+	sections.push(doc.headerComment);
+	const namedTypeEntries = [...doc.namedTypes].sort((a, b) => a.name.localeCompare(b.name));
+	if (namedTypeEntries.length > 0) sections.push(serializeTypesBlock(namedTypeEntries));
+	const blockDispatchMap = buildPslBlockDispatchMap(options.pslBlockDescriptors);
+	for (const namespace of doc.namespaces) {
+		const namespaceSections = serializeNamespaceContents(namespace, blockDispatchMap, options.codecLookup);
+		if (namespaceSections.length === 0) continue;
+		if (namespace.name === "__unspecified__") sections.push(...namespaceSections);
+		else sections.push(wrapNamespaceBlock(namespace.name, namespaceSections));
+	}
+	return `${sections.join("\n\n")}\n`;
+}
+function serializeNamespaceContents(namespace, blockDispatchMap, codecLookup) {
+	const sections = [];
+	for (const model of namespace.models) sections.push(serializeModel(model));
+	for (const extensionBlock of namespace.extensionBlocks) sections.push(serializeExtensionBlock(extensionBlock, blockDispatchMap, codecLookup));
+	return sections;
+}
+function serializeExtensionBlock(extensionBlock, blockDispatchMap, codecLookup) {
+	const descriptor = blockDispatchMap.byKeyword.get(extensionBlock.keyword);
+	if (!descriptor) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `No pslBlockDescriptors contribution registered for extension-contributed block keyword "${extensionBlock.keyword}". Provide a matching pslBlockDescriptors contribution to serializePrintDocument, or remove the block from the input AST.`, { meta: {
+		reason: "block-descriptor-missing",
+		keyword: extensionBlock.keyword
+	} });
+	if (descriptor.discriminator !== extensionBlock.kind) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `The pslBlockDescriptors contribution for keyword "${extensionBlock.keyword}" owns discriminator "${descriptor.discriminator}", but the block carries kind "${extensionBlock.kind}". Provide a matching pslBlockDescriptors contribution to serializePrintDocument, or remove the block from the input AST.`, { meta: {
+		reason: "block-descriptor-kind-mismatch",
+		keyword: extensionBlock.keyword,
+		descriptorDiscriminator: descriptor.discriminator,
+		blockKind: extensionBlock.kind
+	} });
+	const lines = [`${extensionBlock.keyword} ${extensionBlock.name} {`];
+	for (const [paramName, paramDescriptor] of Object.entries(descriptor.parameters)) {
+		const paramValue = extensionBlock.parameters[paramName];
+		if (paramValue === void 0) continue;
+		const rendered = renderParamValue(paramValue, paramDescriptor, codecLookup, paramName);
+		lines.push(`${PSL_INDENT_UNIT}${paramName} = ${rendered}`);
+	}
+	if (descriptor.variadicParameters) for (const [paramName, paramValue] of Object.entries(extensionBlock.parameters)) {
+		if (Object.hasOwn(descriptor.parameters, paramName)) continue;
+		lines.push(`${PSL_INDENT_UNIT}${renderVariadicParam(paramName, paramValue)}`);
+	}
+	for (const attr of extensionBlock.blockAttributes ?? []) {
+		const args = attr.args.map((arg) => arg.value).join(", ");
+		lines.push(`${PSL_INDENT_UNIT}@@${attr.name}${args.length > 0 ? `(${args})` : ""}`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+/**
+* Renders one undeclared parameter of a `variadicParameters` block (e.g. a
+* `native_enum` member line). Variadic entries have no per-parameter
+* descriptor, so there is no codec to round-trip a `value` through — the raw
+* PSL literal is emitted verbatim. A `bare` entry is just its key.
+*/
+function renderVariadicParam(paramName, paramValue) {
+	if (paramValue.kind === "bare") return paramName;
+	return `${paramName} = ${renderVariadicValue(paramValue)}`;
+}
+function renderVariadicValue(paramValue) {
+	switch (paramValue.kind) {
+		case "bare": return "";
+		case "value": return paramValue.raw;
+		case "ref": return paramValue.identifier;
+		case "option": return paramValue.token;
+		case "list": return `[${paramValue.items.map(renderVariadicValue).join(", ")}]`;
+	}
+}
+function renderParamValue(paramValue, descriptor, codecLookup, paramName) {
+	switch (descriptor.kind) {
+		case "ref":
+			if (paramValue.kind !== "ref") throw paramKindMismatchError(paramName, "ref", paramValue.kind);
+			return paramValue.identifier;
+		case "value":
+			if (paramValue.kind !== "value") throw paramKindMismatchError(paramName, "value", paramValue.kind);
+			return renderValueParam(paramValue.raw, descriptor.codecId, codecLookup, paramName);
+		case "option":
+			if (paramValue.kind !== "option") throw paramKindMismatchError(paramName, "option", paramValue.kind);
+			return paramValue.token;
+		case "list":
+			if (paramValue.kind !== "list") throw paramKindMismatchError(paramName, "list", paramValue.kind);
+			return `[${paramValue.items.map((item) => renderParamValue(item, descriptor.of, codecLookup, paramName)).join(", ")}]`;
+	}
+}
+function paramKindMismatchError(paramName, descriptorKind, valueKind) {
+	return contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Extension block parameter "${paramName}": descriptor is "${descriptorKind}" but AST node has kind "${valueKind}"`, { meta: {
+		reason: "param-kind-mismatch",
+		paramName,
+		descriptorKind,
+		valueKind
+	} });
+}
+function renderValueParam(raw, codecId, codecLookup, paramName) {
+	if (!codecLookup) return raw;
+	const codec = codecLookup.get(codecId);
+	if (!codec) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Extension block parameter "${paramName}": no codec registered for id "${codecId}"`, { meta: {
+		reason: "codec-unregistered",
+		paramName,
+		codecId
+	} });
+	let parsedJson;
+	try {
+		parsedJson = JSON.parse(raw);
+	} catch (e) {
+		throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Extension block parameter "${paramName}": codec "${codecId}" — raw literal is not valid JSON: ${String(e)}`, {
+			meta: {
+				reason: "raw-literal-invalid-json",
+				paramName,
+				codecId
+			},
+			cause: e
+		});
+	}
+	return JSON.stringify(codec.encodeJson(codec.decodeJson(blindCast(parsedJson))));
+}
+function wrapNamespaceBlock(name, innerSections) {
+	return `namespace ${name} {\n${innerSections.map((section) => section.split("\n").map((line) => line.length > 0 ? `  ${line}` : line).join("\n")).join("\n\n")}\n}`;
+}
+function serializeTypesBlock(namedTypes) {
+	const lines = ["types {"];
+	for (const nt of namedTypes) {
+		const attrStr = nt.attributes.length > 0 ? ` ${nt.attributes.join(" ")}` : "";
+		lines.push(`  ${nt.name} = ${nt.baseType}${attrStr}`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+function serializeModel(model) {
+	const lines = [];
+	if (model.comment) lines.push(model.comment);
+	lines.push(`model ${model.name} {`);
+	const idFields = model.fields.filter((f) => f.isId);
+	const scalarFields = model.fields.filter((f) => !f.isId && !f.isRelation);
+	const relationFields = model.fields.filter((f) => f.isRelation);
+	const allOrderedFields = [
+		...idFields,
+		...scalarFields,
+		...relationFields
+	];
+	if (allOrderedFields.length > 0) {
+		const maxNameLen = Math.max(...allOrderedFields.map((f) => f.name.length));
+		const maxTypeLen = Math.max(...allOrderedFields.map((f) => formatFieldType(f).length));
+		for (const field of allOrderedFields) {
+			const typePart = formatFieldType(field);
+			const paddedName = field.name.padEnd(maxNameLen);
+			const paddedType = typePart.padEnd(maxTypeLen);
+			if (field.comment) lines.push(`  ${field.comment}`);
+			const attrStr = field.attributes.length > 0 ? ` ${field.attributes.join(" ")}` : "";
+			lines.push(`  ${paddedName} ${paddedType}${attrStr}`.trimEnd());
+		}
+	}
+	if (model.modelAttributes.length > 0) {
+		if (allOrderedFields.length > 0) lines.push("");
+		for (const attr of model.modelAttributes) lines.push(`  ${attr}`);
+	}
+	lines.push("}");
+	return lines.join("\n");
+}
+function formatFieldType(field) {
+	let type = field.typeName;
+	if (field.list) type += "[]";
+	else if (field.optional) type += "?";
+	return type;
+}
+const DEFAULT_AST_PRINT_HEADER = "// use prisma-next\n// Contract inferred from the live database schema. Edit as needed, then run `prisma-next contract emit`.";
+function astDocumentToPrintDocument(ast) {
+	const allModels = flatPslModels(ast);
+	const sortedModels = topologicalSortModels(allModels, buildModelFkDeps(allModels, new Set(allModels.map((m) => m.name))));
+	const modelNamespaceIndex = /* @__PURE__ */ new Map();
+	for (const namespace of ast.namespaces) for (const model of namespace.models) modelNamespaceIndex.set(model.name, namespace.name);
+	const namedTypes = ast.types ? ast.types.declarations.map(namedTypeDeclarationToPrinterNamedType) : [];
+	const namespaceSections = ast.namespaces.map((namespace) => {
+		const printerModels = sortedModels.filter((model) => modelNamespaceIndex.get(model.name) === namespace.name).map((m) => modelToPrinterModel(m));
+		return {
+			name: namespace.name,
+			models: printerModels,
+			extensionBlocks: namespacePslExtensionBlocks(namespace)
+		};
+	});
+	namespaceSections.sort((a, b) => {
+		if (a.name === b.name) return 0;
+		if (a.name === "__unspecified__") return -1;
+		if (b.name === "__unspecified__") return 1;
+		return a.name.localeCompare(b.name);
+	});
+	return {
+		headerComment: DEFAULT_AST_PRINT_HEADER,
+		namedTypes,
+		namespaces: namespaceSections
+	};
+}
+function renderPslAttribute(attr) {
+	const prefix = attr.target === "model" || attr.target === "enum" ? "@@" : "@";
+	if (attr.args.length === 0) return `${prefix}${attr.name}`;
+	const inner = attr.args.map(renderAttributeArgument).join(", ");
+	return `${prefix}${attr.name}(${inner})`;
+}
+function renderAttributeArgument(arg) {
+	if (arg.kind === "positional") return arg.value;
+	return `${arg.name}: ${arg.value}`;
+}
+function namedTypeDeclarationToPrinterNamedType(decl) {
+	const base = decl.baseType ?? (decl.typeConstructor !== void 0 ? formatTypeConstructor(decl.typeConstructor) : "");
+	const attributes = decl.attributes.map(renderPslAttribute);
+	return {
+		name: decl.name,
+		baseType: base,
+		attributes
+	};
+}
+function formatTypeConstructor(tc) {
+	const path = tc.path.join(".");
+	if (tc.args.length === 0) return path;
+	return `${path}(${tc.args.map(renderAttributeArgument).join(", ")})`;
+}
+function getPositionalStringArg(attr, index) {
+	const raw = attr.args.filter((a) => a.kind === "positional")[index]?.value.trim();
+	if (!raw) return void 0;
+	const m = raw.match(/^(['"])(.*)\1$/);
+	if (!m) return void 0;
+	return unescapePslString(m[2]);
+}
+/**
+* Inverse of `escapePslString`. The parser stores quoted-literal arguments with
+* their PSL escape sequences (`\\`, `\"`, `\n`, `\r`) intact; when we round-trip
+* a value through `getPositionalStringArg` and re-render via `escapePslString`,
+* we must decode it once on extraction to avoid double-escaping the same
+* sequences on output.
+*/
+function unescapePslString(value) {
+	let result = "";
+	for (let i = 0; i < value.length; i++) {
+		if (value.charCodeAt(i) !== 92 || i + 1 >= value.length) {
+			result += value[i];
+			continue;
+		}
+		const next = value[i + 1];
+		if (next === "\\" || next === "\"" || next === "'") result += next;
+		else if (next === "n") result += "\n";
+		else if (next === "r") result += "\r";
+		else {
+			result += "\\";
+			result += next;
+		}
+		i++;
+	}
+	return result;
+}
+function modelToPrinterModel(model) {
+	let mapName;
+	const modelAttrStrings = [];
+	for (const a of model.attributes) {
+		if (a.name === "map" && a.target === "model") {
+			mapName = getPositionalStringArg(a, 0) ?? mapName;
+			continue;
+		}
+		modelAttrStrings.push(renderPslAttribute(a));
+	}
+	if (mapName !== void 0) modelAttrStrings.push(`@@map("${escapePslString(mapName)}")`);
+	const printerFields = model.fields.map((f) => fieldToPrinterField(f));
+	return {
+		name: model.name,
+		mapName,
+		fields: printerFields,
+		modelAttributes: modelAttrStrings,
+		comment: model.comment
+	};
+}
+/**
+* Assembles the qualified type name string for a field type reference.
+*
+* Handles all four forms:
+* - `space:ns.Name`  — typeContractSpaceId + typeNamespaceId + typeName
+* - `space:Name`     — typeContractSpaceId + typeName (no namespace)
+* - `ns.Name`        — typeNamespaceId + typeName (no space); fixes TML-2459 printer gap
+* - `Name`           — typeName only (no qualifier)
+*/
+function assembleQualifiedTypeName(field) {
+	const { typeName, typeNamespaceId, typeContractSpaceId } = field;
+	const dotted = typeNamespaceId !== void 0 ? `${typeNamespaceId}.${typeName}` : typeName;
+	return typeContractSpaceId !== void 0 ? `${typeContractSpaceId}:${dotted}` : dotted;
+}
+function fieldToPrinterField(field) {
+	const typeName = field.typeConstructor !== void 0 ? formatTypeConstructor(field.typeConstructor) : assembleQualifiedTypeName(field);
+	let mapName;
+	const attrStrings = [];
+	for (const a of field.attributes) {
+		if (a.name === "map" && a.target === "field") {
+			mapName = getPositionalStringArg(a, 0) ?? mapName;
+			continue;
+		}
+		attrStrings.push(renderPslAttribute(a));
+	}
+	if (mapName !== void 0) attrStrings.push(`@map("${escapePslString(mapName)}")`);
+	const isRelation = field.attributes.some((a) => a.name === "relation" && a.target === "field");
+	const isUnsupported = typeName.startsWith("Unsupported(");
+	const isId = field.attributes.some((a) => a.name === "id" && a.target === "field");
+	return {
+		name: field.name,
+		typeName,
+		optional: field.optional,
+		list: field.list,
+		attributes: attrStrings,
+		mapName,
+		isId,
+		isRelation,
+		isUnsupported,
+		comment: void 0
+	};
+}
+function buildModelFkDeps(models, modelNames) {
+	const deps = /* @__PURE__ */ new Map();
+	for (const m of models) deps.set(m.name, /* @__PURE__ */ new Set());
+	for (const m of models) for (const field of m.fields) {
+		const refModel = relationReferencedModel(field, modelNames);
+		if (!refModel || refModel === m.name) continue;
+		if (!hasFullRelation(field)) continue;
+		deps.get(m.name).add(refModel);
+	}
+	return deps;
+}
+function hasFullRelation(field) {
+	const rel = field.attributes.find((a) => a.name === "relation" && a.target === "field");
+	if (!rel) return false;
+	const named = Object.fromEntries(rel.args.filter((a) => a.kind === "named").map((a) => [a.name, a.value.trim()]));
+	return named["fields"] !== void 0 && named["references"] !== void 0;
+}
+function relationReferencedModel(field, modelNames) {
+	const raw = field.typeConstructor?.path[0] ?? field.typeName.replace(/\?$/, "").replace(/\[\]$/, "");
+	if (raw.length === 0) return;
+	return modelNames.has(raw) ? raw : void 0;
+}
+function topologicalSortModels(models, deps) {
+	const byName = new Map(models.map((m) => [m.name, m]));
+	const result = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const sortedNames = [...deps.keys()].sort();
+	function visit(name) {
+		if (visited.has(name)) return;
+		if (visiting.has(name)) return;
+		visiting.add(name);
+		const sortedDeps = [...deps.get(name) ?? /* @__PURE__ */ new Set()].sort();
+		for (const dep of sortedDeps) visit(dep);
+		visiting.delete(name);
+		visited.add(name);
+		const model = byName.get(name);
+		if (model) result.push(model);
+	}
+	for (const name of sortedNames) visit(name);
+	return result;
+}
+function printPslFromAst(ast, options = {}) {
+	return serializePrintDocument(astDocumentToPrintDocument(ast), {
+		...ifDefined("pslBlockDescriptors", options.pslBlockDescriptors),
+		...ifDefined("codecLookup", options.codecLookup)
+	});
+}
+//#endregion
+export { printPslFromAst as printPsl };
+
+//# sourceMappingURL=psl-printer.mjs.map