@prisma-next/psl-parser 0.14.0-dev.9 → 0.14.0-dev.90

package/dist/symbol-table-C-AH04Ug.d.mts

@@ -0,0 +1,127 @@
+import { $ as Range, H as SyntaxNode, T as ExpressionAst, b as FieldAttributeAst, c as DocumentAst, et as SourceFile, h as NamespaceDeclarationAst, l as FieldDeclarationAst, m as NamedTypeDeclarationAst, o as CompositeTypeDeclarationAst, p as ModelDeclarationAst, t as ParseDiagnostic, u as GenericBlockDeclarationAst, v as TypeAnnotationAst, x as ModelAttributeAst } from "./parse-BazJr7Ye.mjs";
+import { PslExtensionBlock, PslSpan } from "@prisma-next/framework-components/psl-ast";
+import { AuthoringPslBlockDescriptorNamespace } from "@prisma-next/framework-components/authoring";
+
+//#region src/resolve.d.ts
+interface ResolvedAttributeArg {
+  readonly kind: 'positional' | 'named';
+  readonly name?: string;
+  readonly value: string;
+  readonly expression?: ExpressionAst;
+  readonly span: PslSpan;
+}
+interface ResolvedAttribute {
+  readonly name: string;
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+interface ResolvedTypeConstructorCall {
+  readonly path: readonly string[];
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+declare function readResolvedAttribute(attribute: FieldAttributeAst | ModelAttributeAst, sourceFile: SourceFile): ResolvedAttribute;
+declare function readResolvedAttributes(attributes: Iterable<FieldAttributeAst | ModelAttributeAst>, sourceFile: SourceFile): readonly ResolvedAttribute[];
+declare function readResolvedConstructorCall(annotation: TypeAnnotationAst | undefined, sourceFile: SourceFile): ResolvedTypeConstructorCall | undefined;
+declare function nodePslSpan(node: SyntaxNode, sourceFile: SourceFile): PslSpan;
+/** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
+declare function keywordPslSpan(node: SyntaxNode, keyword: string, sourceFile: SourceFile): PslSpan;
+declare function rangeToPslSpan(range: Range, sourceFile: SourceFile): PslSpan;
+//#endregion
+//#region src/symbol-table.d.ts
+interface SymbolTable {
+  readonly topLevel: TopLevelScope;
+}
+interface TopLevelScope {
+  readonly namespaces: Record<string, NamespaceSymbol>;
+  readonly scalars: Record<string, ScalarSymbol>;
+  readonly typeAliases: Record<string, TypeAliasSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+}
+interface NamespaceSymbol {
+  readonly kind: 'namespace';
+  readonly name: string;
+  readonly node: NamespaceDeclarationAst;
+  readonly span: PslSpan;
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+}
+interface ModelSymbol {
+  readonly kind: 'model';
+  readonly name: string;
+  readonly node: ModelDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+interface CompositeTypeSymbol {
+  readonly kind: 'compositeType';
+  readonly name: string;
+  readonly node: CompositeTypeDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+interface BlockSymbol {
+  readonly kind: 'block';
+  readonly name: string;
+  readonly keyword: string;
+  readonly node: GenericBlockDeclarationAst;
+  readonly span: PslSpan;
+  /** Resolved once so consumers do not independently classify block parameters. */
+  readonly block: PslExtensionBlock;
+}
+interface ResolvedNamedTypeBinding {
+  readonly baseType?: string;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly isConstructor: boolean;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+interface ScalarSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'scalar';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+interface TypeAliasSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'typeAlias';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+interface FieldSymbol {
+  readonly kind: 'field';
+  readonly name: string;
+  readonly node: FieldDeclarationAst;
+  readonly span: PslSpan;
+  readonly typeName: string;
+  readonly typeNamespaceId?: string;
+  readonly typeContractSpaceId?: string;
+  readonly optional: boolean;
+  readonly list: boolean;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly attributes: readonly ResolvedAttribute[];
+  /** Prevents cascading unsupported-type diagnostics after invalid qualification. */
+  readonly malformedType?: boolean;
+}
+interface BuildSymbolTableOptions {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+  readonly scalarTypes: readonly string[];
+  readonly pslBlockDescriptors: AuthoringPslBlockDescriptorNamespace;
+}
+interface SymbolTableResult {
+  readonly table: SymbolTable;
+  readonly diagnostics: readonly ParseDiagnostic[];
+}
+/**
+ * Owns duplicate-declaration detection for all PSL scopes; downstream consumers
+ * should consume first-wins symbols rather than re-emitting duplicate diagnostics.
+ */
+declare function buildSymbolTable(options: BuildSymbolTableOptions): SymbolTableResult;
+//#endregion
+export { readResolvedConstructorCall as S, keywordPslSpan as _, ModelSymbol as a, readResolvedAttribute as b, ScalarSymbol as c, TopLevelScope as d, TypeAliasSymbol as f, ResolvedTypeConstructorCall as g, ResolvedAttributeArg as h, FieldSymbol as i, SymbolTable as l, ResolvedAttribute as m, BuildSymbolTableOptions as n, NamespaceSymbol as o, buildSymbolTable as p, CompositeTypeSymbol as r, ResolvedNamedTypeBinding as s, BlockSymbol as t, SymbolTableResult as u, nodePslSpan as v, readResolvedAttributes as x, rangeToPslSpan as y };
+//# sourceMappingURL=symbol-table-C-AH04Ug.d.mts.map

package/dist/symbol-table-C-AH04Ug.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-table-C-AH04Ug.d.mts","names":[],"sources":["../src/resolve.ts","../src/symbol-table.ts"],"mappings":"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"}

package/dist/syntax.d.mts

@@ -1,4 +1,4 @@
-import { A as AstNode, B as GreenNode, C as NumberLiteralExprAst, D as castExpression, E as StringLiteralExprAst, F as SyntaxElement, G as Position, H as greenNode, I as SyntaxNode, K as Range, L as SyntaxToken, M as findChildToken, N as findFirstChild, O as QualifiedNameAst, P as printSyntax, R as createSyntaxTree, S as FunctionCallAst, T as ObjectLiteralExprAst, U as greenToken, V as GreenToken, W as SyntaxKind, _ as ModelAttributeAst, a as DocumentAst, b as BooleanLiteralExprAst, c as KeyValuePairAst, d as NamespaceDeclarationAst, f as NamespaceMemberAst, g as FieldAttributeAst, h as AttributeArgListAst, i as CompositeTypeDeclarationAst, j as filterChildren, k as IdentifierAst, l as ModelDeclarationAst, m as TypeAnnotationAst, n as ParseResult, o as FieldDeclarationAst, p as TypesBlockAst, q as SourceFile, r as parse, s as GenericBlockDeclarationAst, t as ParseDiagnostic, u as NamedTypeDeclarationAst, v as ArrayLiteralAst, w as ObjectFieldAst, x as ExpressionAst, y as AttributeArgAst, z as GreenElement } from "./parse-BjZ1LPe6.mjs";
+import { $ as Range, A as StringLiteralExprAst, B as printSyntax, C as AttributeArgAst, D as NumberLiteralExprAst, E as FunctionCallAst, F as BracedBlock, G as createSyntaxTree, H as SyntaxNode, I as any, J as GreenToken, K as GreenElement, L as filterChildren, M as QualifiedNameAst, N as IdentifierAst, O as ObjectFieldAst, P as AstNode, Q as Position, R as findChildToken, S as ArrayLiteralAst, T as ExpressionAst, U as SyntaxToken, V as SyntaxElement, W as TokenAtOffset, X as greenToken, Y as greenNode, Z as SyntaxKind, _ as TypesBlockAst, a as BlockMemberAst, b as FieldAttributeAst, c as DocumentAst, d as GenericBlockMemberAst, et as SourceFile, f as KeyValuePairAst, g as NamespaceMemberAst, h as NamespaceDeclarationAst, i as AttributeAst, j as castExpression, k as ObjectLiteralExprAst, l as FieldDeclarationAst, m as NamedTypeDeclarationAst, n as ParseResult, o as CompositeTypeDeclarationAst, p as ModelDeclarationAst, q as GreenNode, r as parse, s as DeclarationAst, t as ParseDiagnostic, u as GenericBlockDeclarationAst, v as TypeAnnotationAst, w as BooleanLiteralExprAst, x as ModelAttributeAst, y as AttributeArgListAst, z as findFirstChild } from "./parse-BazJr7Ye.mjs";
 import { n as TokenKind } from "./tokenizer-DcYI0Xrq.mjs";
 
 //#region src/syntax/green-builder.d.ts
@@ -9,5 +9,23 @@ declare class GreenNodeBuilder {
   finishNode(): GreenNode;
 }
 //#endregion
-export { ArrayLiteralAst, type AstNode, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, DocumentAst, type ExpressionAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, 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, type SyntaxToken, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
+//#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=syntax.d.mts.map

package/dist/syntax.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"syntax.d.mts","names":[],"sources":["../src/syntax/green-builder.ts"],"mappings":";;;;cAKa,gBAAA;EAAA;EAGX,SAAA,CAAU,IAAA,EAAM,UAAA;EAIhB,KAAA,CAAM,IAAA,EAAM,SAAA,EAAW,IAAA;EAQvB,UAAA,IAAc,SAAA;AAAA"}
+{"version":3,"file":"syntax.d.mts","names":[],"sources":["../src/syntax/green-builder.ts","../src/syntax/navigation.ts"],"mappings":";;;;cAKa,gBAAA;EAAA;EAGX,SAAA,CAAU,IAAA,EAAM,UAAA;EAIhB,KAAA,CAAM,IAAA,EAAM,SAAA,EAAW,IAAA;EAQvB,UAAA,IAAc,SAAA;AAAA;;;;KChBJ,SAAA;ADCZ;AAAA,iBCQgB,YAAA,CAAa,IAAe,EAAT,SAAS;;iBAK5B,QAAA,CAAS,KAAkB,EAAX,WAAW;;;;;iBAQ3B,eAAA,CAAgB,KAAA,EAAO,WAAA,EAAa,SAAA,EAAW,SAAA,GAAY,WAAA;;;;;iBAY3D,gBAAA,CACd,OAAA,EAAS,aAAA,EACT,SAAA,EAAW,SAAA,GACV,aAAA"}

package/dist/syntax.mjs

@@ -1,3 +1,43 @@
-import { A as createSyntaxTree, C as QualifiedNameAst, D as findFirstChild, E as findChildToken, O as printSyntax, S as castExpression, T as filterChildren, _ 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, k as SyntaxNode, 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-D9h_ihD3.mjs";
-import { a as SourceFile, i as greenToken, n as GreenNodeBuilder, r as greenNode, t as parse } from "./parse-DhEV6av6.mjs";
-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, TypeAnnotationAst, TypesBlockAst, castExpression, createSyntaxTree, filterChildren, findChildToken, findFirstChild, greenNode, greenToken, parse, printSyntax };
+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";
+import { a as SourceFile, i as greenToken, n as GreenNodeBuilder, r as greenNode, t as parse } from "./parse-CdeXr0T3.mjs";
+//#region src/syntax/navigation.ts
+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=syntax.mjs.map

package/dist/syntax.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.mjs","names":[],"sources":["../src/syntax/navigation.ts"],"sourcesContent":["import type { TokenKind } from '../tokenizer';\nimport { type SyntaxElement, SyntaxToken } from './red';\n\n/** Direction of a sibling/token walk. */\nexport type Direction = 'next' | 'prev';\n\nconst TRIVIA_KINDS: ReadonlySet<TokenKind> = new Set<TokenKind>([\n  'Whitespace',\n  'Newline',\n  'Comment',\n]);\n\n/** Whether a token kind is trivia (whitespace, newline, or comment). */\nexport function isTriviaKind(kind: TokenKind): boolean {\n  return TRIVIA_KINDS.has(kind);\n}\n\n/** Whether a token is trivia. */\nexport function isTrivia(token: SyntaxToken): boolean {\n  return isTriviaKind(token.kind);\n}\n\n/**\n * The first non-trivia token at or beyond `token` in `direction`. Returns\n * `token` itself when it is already significant.\n */\nexport function skipTriviaToken(token: SyntaxToken, direction: Direction): SyntaxToken | undefined {\n  let current: SyntaxToken | undefined = token;\n  while (current !== undefined && isTrivia(current)) {\n    current = direction === 'next' ? current.nextToken : current.prevToken;\n  }\n  return current;\n}\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 */\nexport function nonTriviaSibling(\n  element: SyntaxElement,\n  direction: Direction,\n): SyntaxElement | undefined {\n  let sibling = step(element, direction);\n  while (sibling !== undefined) {\n    if (!(sibling instanceof SyntaxToken) || !isTrivia(sibling)) {\n      return sibling;\n    }\n    sibling = step(sibling, direction);\n  }\n  return undefined;\n}\n\nfunction step(element: SyntaxElement, direction: Direction): SyntaxElement | undefined {\n  return direction === 'next' ? element.nextSiblingOrToken : element.prevSiblingOrToken;\n}\n"],"mappings":";;;AAMA,MAAM,+BAAuC,IAAI,IAAe;CAC9D;CACA;CACA;AACF,CAAC;;AAGD,SAAgB,aAAa,MAA0B;CACrD,OAAO,aAAa,IAAI,IAAI;AAC9B;;AAGA,SAAgB,SAAS,OAA6B;CACpD,OAAO,aAAa,MAAM,IAAI;AAChC;;;;;AAMA,SAAgB,gBAAgB,OAAoB,WAA+C;CACjG,IAAI,UAAmC;CACvC,OAAO,YAAY,KAAA,KAAa,SAAS,OAAO,GAC9C,UAAU,cAAc,SAAS,QAAQ,YAAY,QAAQ;CAE/D,OAAO;AACT;;;;;AAMA,SAAgB,iBACd,SACA,WAC2B;CAC3B,IAAI,UAAU,KAAK,SAAS,SAAS;CACrC,OAAO,YAAY,KAAA,GAAW;EAC5B,IAAI,EAAE,mBAAmB,gBAAgB,CAAC,SAAS,OAAO,GACxD,OAAO;EAET,UAAU,KAAK,SAAS,SAAS;CACnC;AAEF;AAEA,SAAS,KAAK,SAAwB,WAAiD;CACrF,OAAO,cAAc,SAAS,QAAQ,qBAAqB,QAAQ;AACrE"}

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@prisma-next/psl-parser",
-  "version": "0.14.0-dev.9",
+  "version": "0.14.0-dev.90",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Reusable parser for Prisma Schema Language (PSL)",
   "dependencies": {
-    "@prisma-next/framework-components": "0.14.0-dev.9",
-    "@prisma-next/utils": "0.14.0-dev.9"
+    "@prisma-next/config": "0.14.0-dev.90",
+    "@prisma-next/contract": "0.14.0-dev.90",
+    "@prisma-next/framework-components": "0.14.0-dev.90",
+    "@prisma-next/utils": "0.14.0-dev.90"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.14.0-dev.9",
-    "@prisma-next/tsdown": "0.14.0-dev.9",
-    "tsdown": "0.22.1",
+    "@prisma-next/tsconfig": "0.14.0-dev.90",
+    "@prisma-next/tsdown": "0.14.0-dev.90",
+    "tsdown": "0.22.3",
     "typescript": "5.9.3",
-    "vitest": "4.1.8"
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
     "typescript": ">=5.9"
@@ -32,6 +34,7 @@
   "exports": {
     ".": "./dist/index.mjs",
     "./format": "./dist/format.mjs",
+    "./interpret": "./dist/interpret.mjs",
     "./syntax": "./dist/syntax.mjs",
     "./tokenizer": "./dist/tokenizer.mjs",
     "./package.json": "./package.json"

package/src/attribute-spec/combinators/bool.ts

@@ -0,0 +1,19 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { BooleanLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function bool(): ArgType<boolean> {
+  return {
+    kind: 'bool',
+    label: 'boolean',
+    parse: (arg, ctx): Result<boolean, readonly PslDiagnostic[]> => {
+      if (arg instanceof BooleanLiteralExprAst) {
+        const value = arg.value();
+        if (value !== undefined) return ok(value);
+      }
+      return notOk([leafDiagnostic(ctx, arg, 'Expected a boolean literal')]);
+    },
+  };
+}

package/src/attribute-spec/combinators/diagnostic.ts

@@ -0,0 +1,15 @@
+import type { PslDiagnostic, PslDiagnosticCode } from '@prisma-next/framework-components/psl-ast';
+import { nodePslSpan } from '../../resolve';
+import type { AstNode } from '../../syntax/ast-helpers';
+import type { InterpretCtx } from '../types';
+
+export const ATTRIBUTE_DIAGNOSTIC_CODE: PslDiagnosticCode = 'PSL_INVALID_ATTRIBUTE_SYNTAX';
+
+export function leafDiagnostic(ctx: InterpretCtx, node: AstNode, message: string): PslDiagnostic {
+  return {
+    code: ATTRIBUTE_DIAGNOSTIC_CODE,
+    message,
+    sourceId: ctx.sourceId,
+    span: nodePslSpan(node.syntax, ctx.sourceFile),
+  };
+}

package/src/attribute-spec/combinators/entity-ref.ts

@@ -0,0 +1,24 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+// A bare model-name reference. Existence of a model with this name is resolved
+// downstream (e.g. `resolvePolymorphism`), not here.
+export function entityRef(): ArgType<string> {
+  return {
+    kind: 'entityRef',
+    label: 'model name',
+    parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof IdentifierAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
+      }
+      const name = arg.name();
+      if (name === undefined) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a model name')]);
+      }
+      return ok(name);
+    },
+  };
+}

package/src/attribute-spec/combinators/field-ref.ts

@@ -0,0 +1,36 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export type FieldRefScope = 'self' | 'referenced';
+
+export interface FieldRefArgType extends ArgType<string> {
+  readonly scope: FieldRefScope;
+}
+
+export function fieldRef(scope: FieldRefScope): FieldRefArgType {
+  return {
+    kind: 'fieldRef',
+    label: 'field name',
+    scope,
+    parse: (arg, ctx): Result<string, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof IdentifierAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
+      }
+      const name = arg.name();
+      if (name === undefined) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected a field name')]);
+      }
+      const model = scope === 'self' ? ctx.selfModel : ctx.resolveReferencedModel();
+      // A referenced model in another space can't be resolved here (resolveReferencedModel returns undefined); skip the existence check — it runs where that model is known.
+      if (model !== undefined && !Object.hasOwn(model.fields, name)) {
+        return notOk([
+          leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`),
+        ]);
+      }
+      return ok(name);
+    },
+  };
+}

package/src/attribute-spec/combinators/func-call.ts

@@ -0,0 +1,65 @@
+import type { PslDiagnostic, PslSpan } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { nodePslSpan } from '../../resolve';
+import type { ExpressionAst } from '../../syntax/ast/expressions';
+import { FunctionCallAst } from '../../syntax/ast/expressions';
+import { interpretArgs } from '../interpret';
+import type { ArgType, InterpretCtx, Param, PositionalParam } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+// The argument signature of a pinned function call — the same positional/named shape an attribute
+// spec uses. Omitted groups default to empty, so a nullary call needs neither key.
+export interface FuncCallSig {
+  readonly positional?: readonly PositionalParam<unknown>[];
+  readonly named?: Readonly<Record<string, Param<unknown>>>;
+}
+
+export interface TypedFuncCall {
+  readonly fn: string;
+  readonly span: PslSpan;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+
+// A name-pinned function-call argument — `funcCall('now', {})` matches `now()`, parsing the call's
+// arguments through `sig`.
+export function funcCall(name: string, sig: FuncCallSig): ArgType<TypedFuncCall> {
+  return {
+    kind: 'funcCall',
+    label: 'function call',
+    parse: (arg, ctx): Result<TypedFuncCall, readonly PslDiagnostic[]> => {
+      const guard = matchCallee(arg, name, ctx);
+      if (!guard.ok) return guard;
+      const span = nodePslSpan(guard.value.syntax, ctx.sourceFile);
+      const bound = interpretArgs(
+        guard.value.args(),
+        { name, positional: sig.positional ?? [], named: sig.named ?? {} },
+        ctx,
+        span,
+      );
+      if (!bound.ok) return notOk<readonly PslDiagnostic[]>(bound.failure);
+      return ok({ fn: name, span, args: bound.value });
+    },
+  };
+}
+
+function matchCallee(
+  arg: ExpressionAst,
+  name: string,
+  ctx: InterpretCtx,
+): Result<FunctionCallAst, readonly PslDiagnostic[]> {
+  if (!(arg instanceof FunctionCallAst)) {
+    return notOk([leafDiagnostic(ctx, arg, 'Expected a function call')]);
+  }
+  const qname = arg.name();
+  if (qname === undefined || qname.dot() !== undefined || qname.colon() !== undefined) {
+    return notOk([leafDiagnostic(ctx, arg, 'Expected a function call')]);
+  }
+  const calleeName = qname.identifier()?.token()?.text;
+  if (calleeName === undefined) {
+    return notOk([leafDiagnostic(ctx, arg, 'Expected a function call')]);
+  }
+  if (calleeName !== name) {
+    return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
+  }
+  return ok(arg);
+}

package/src/attribute-spec/combinators/identifier.ts

@@ -0,0 +1,16 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { IdentifierAst } from '../../syntax/ast/identifier';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function identifier<const N extends string>(name: N): ArgType<N> {
+  return {
+    kind: 'identifier',
+    label: name,
+    parse: (arg, ctx): Result<N, readonly PslDiagnostic[]> => {
+      if (arg instanceof IdentifierAst && arg.name() === name) return ok(name);
+      return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
+    },
+  };
+}

package/src/attribute-spec/combinators/int.ts

@@ -0,0 +1,35 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { NumberLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+// An integer literal reduced to its numeric value. Passing `min`/`max` additionally rejects
+// out-of-range integers with a distinct range message, leaving the integer-only check intact.
+export function int(opts?: { min?: number; max?: number }): ArgType<number> {
+  const min = opts?.min;
+  const max = opts?.max;
+  return {
+    kind: 'int',
+    label: 'integer',
+    parse: (arg, ctx): Result<number, readonly PslDiagnostic[]> => {
+      if (arg instanceof NumberLiteralExprAst) {
+        const value = arg.value();
+        if (value !== undefined && Number.isInteger(value)) {
+          if ((min === undefined || value >= min) && (max === undefined || value <= max)) {
+            return ok(value);
+          }
+          return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
+        }
+      }
+      return notOk([leafDiagnostic(ctx, arg, 'Expected an integer literal')]);
+    },
+  };
+}
+
+function rangeMessage(min: number | undefined, max: number | undefined): string {
+  if (min !== undefined && max !== undefined)
+    return `Expected an integer between ${min} and ${max}`;
+  if (min !== undefined) return `Expected an integer greater than or equal to ${min}`;
+  return `Expected an integer less than or equal to ${max}`;
+}

package/src/attribute-spec/combinators/list.ts

@@ -0,0 +1,43 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { ArrayLiteralAst, type ExpressionAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export interface ListOptions {
+  readonly nonEmpty?: boolean;
+  readonly unique?: boolean;
+}
+
+export function list<T>(of: ArgType<T>, opts?: ListOptions): ArgType<T[]> {
+  return {
+    kind: 'list',
+    label: `${of.label}[]`,
+    parse: (arg, ctx): Result<T[], readonly PslDiagnostic[]> => {
+      if (!(arg instanceof ArrayLiteralAst)) {
+        return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+      }
+      const diagnostics: PslDiagnostic[] = [];
+      const parsed: { node: ExpressionAst; value: T }[] = [];
+      let count = 0;
+      for (const element of arg.elements()) {
+        count += 1;
+        const result = of.parse(element, ctx);
+        if (result.ok) parsed.push({ node: element, value: result.value });
+        else diagnostics.push(...result.failure);
+      }
+      if (opts?.nonEmpty === true && count === 0) {
+        diagnostics.push(leafDiagnostic(ctx, arg, 'Expected a non-empty list'));
+      }
+      if (opts?.unique === true) {
+        const seen = new Set<T>();
+        for (const { node, value } of parsed) {
+          if (seen.has(value)) diagnostics.push(leafDiagnostic(ctx, node, 'Duplicate list entry'));
+          else seen.add(value);
+        }
+      }
+      if (diagnostics.length > 0) return notOk(diagnostics);
+      return ok(parsed.map((entry) => entry.value));
+    },
+  };
+}

package/src/attribute-spec/combinators/num.ts

@@ -0,0 +1,26 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { NumberLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+// A general number literal — any number, including floats — reduced to its numeric value.
+// Passing `value` pins the combinator to that single literal (`num(4)` matches only `4`),
+// mirroring how `identifier(name)` pins a bare identifier. Use `int()` when only integer
+// literals are allowed.
+export function num(): ArgType<number>;
+export function num(value: number): ArgType<number>;
+export function num(value?: number): ArgType<number> {
+  return {
+    kind: 'num',
+    label: value === undefined ? 'number' : String(value),
+    parse: (arg, ctx): Result<number, readonly PslDiagnostic[]> => {
+      if (arg instanceof NumberLiteralExprAst) {
+        const parsed = arg.value();
+        if (parsed !== undefined && (value === undefined || parsed === value)) return ok(parsed);
+      }
+      const message = value === undefined ? 'Expected a number literal' : `Expected ${value}`;
+      return notOk([leafDiagnostic(ctx, arg, message)]);
+    },
+  };
+}

package/src/attribute-spec/combinators/one-of.ts

@@ -0,0 +1,29 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import type { ArgType, OutOf } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function oneOf<Alts extends readonly [ArgType<unknown>, ...ArgType<unknown>[]]>(
+  ...alts: Alts
+): ArgType<OutOf<Alts[number]>> {
+  const label = alts.map((alt) => alt.label).join(' | ');
+  return {
+    kind: 'oneOf',
+    label,
+    parse: (arg, ctx): Result<OutOf<Alts[number]>, readonly PslDiagnostic[]> => {
+      for (const alt of alts) {
+        const result = alt.parse(arg, ctx);
+        if (result.ok) {
+          return ok(
+            blindCast<
+              OutOf<Alts[number]>,
+              'The matched value comes from an alternative whose output type is a member of the union, but iterating the tuple widens each element to ArgType<unknown>, erasing that relationship.'
+            >(result.value),
+          );
+        }
+      }
+      return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
+    },
+  };
+}

package/src/attribute-spec/combinators/record.ts

@@ -0,0 +1,43 @@
+import type { PslDiagnostic } from '@prisma-next/framework-components/psl-ast';
+import { notOk, ok, type Result } from '@prisma-next/utils/result';
+import { ObjectLiteralExprAst } from '../../syntax/ast/expressions';
+import type { ArgType } from '../types';
+import { leafDiagnostic } from './diagnostic';
+
+export function record<T>(of: ArgType<T>): ArgType<Record<string, T>> {
+  return {
+    kind: 'record',
+    label: `{ [key]: ${of.label} }`,
+    parse: (arg, ctx): Result<Record<string, T>, readonly PslDiagnostic[]> => {
+      if (!(arg instanceof ObjectLiteralExprAst)) {
+        return notOk([leafDiagnostic(ctx, arg, 'Expected an object literal')]);
+      }
+      const diagnostics: PslDiagnostic[] = [];
+      const result: Record<string, T> = {};
+      for (const field of arg.fields()) {
+        const key = field.keyName();
+        if (key === undefined) {
+          diagnostics.push(leafDiagnostic(ctx, field, 'Expected a key'));
+          continue;
+        }
+        const value = field.value();
+        if (value === undefined) {
+          diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+          continue;
+        }
+        const parsed = of.parse(value, ctx);
+        if (!parsed.ok) {
+          diagnostics.push(...parsed.failure);
+          continue;
+        }
+        if (Object.hasOwn(result, key)) {
+          diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+          continue;
+        }
+        result[key] = parsed.value;
+      }
+      if (diagnostics.length > 0) return notOk(diagnostics);
+      return ok(result);
+    },
+  };
+}