@abapify/acds 0.4.0 → 0.4.1

package/dist/index.mjs

@@ -0,0 +1,1660 @@
+import { CstParser, Lexer, createToken } from "chevrotain";
+
+//#region src/tokens.ts
+/**
+* Chevrotain Token Definitions for ABAP CDS
+*
+* Token order matters: more specific patterns must come before general ones.
+* Keywords use `longer_alt` to avoid matching prefixes of identifiers.
+*/
+const WhiteSpace = createToken({
+	name: "WhiteSpace",
+	pattern: /\s+/,
+	group: Lexer.SKIPPED
+});
+const LineComment = createToken({
+	name: "LineComment",
+	pattern: /\/\/[^\n]*/,
+	group: Lexer.SKIPPED
+});
+const BlockComment = createToken({
+	name: "BlockComment",
+	pattern: /\/\*[\s\S]*?\*\//,
+	group: Lexer.SKIPPED
+});
+const StringLiteral = createToken({
+	name: "StringLiteral",
+	pattern: /'(?:[^'\\]|\\.)*'/
+});
+const NumberLiteral = createToken({
+	name: "NumberLiteral",
+	pattern: /\d+(?:\.\d+)?/
+});
+/** Hash-prefixed enum value: #TRANSPARENT, #NOT_EXTENSIBLE */
+const EnumLiteral = createToken({
+	name: "EnumLiteral",
+	pattern: /#[A-Za-z_][A-Za-z0-9_]*/
+});
+const Identifier = createToken({
+	name: "Identifier",
+	pattern: /[A-Za-z_][A-Za-z0-9_]*/
+});
+const Define = createToken({
+	name: "Define",
+	pattern: /define/,
+	longer_alt: Identifier
+});
+const Table = createToken({
+	name: "Table",
+	pattern: /table/,
+	longer_alt: Identifier
+});
+const Structure = createToken({
+	name: "Structure",
+	pattern: /structure/,
+	longer_alt: Identifier
+});
+const Type = createToken({
+	name: "Type",
+	pattern: /type/,
+	longer_alt: Identifier
+});
+const Service = createToken({
+	name: "Service",
+	pattern: /service/,
+	longer_alt: Identifier
+});
+const Expose = createToken({
+	name: "Expose",
+	pattern: /expose/,
+	longer_alt: Identifier
+});
+const Annotate = createToken({
+	name: "Annotate",
+	pattern: /annotate/,
+	longer_alt: Identifier
+});
+const Entity = createToken({
+	name: "Entity",
+	pattern: /entity/,
+	longer_alt: Identifier
+});
+const With = createToken({
+	name: "With",
+	pattern: /with/,
+	longer_alt: Identifier
+});
+const Key = createToken({
+	name: "Key",
+	pattern: /key/,
+	longer_alt: Identifier
+});
+const Not = createToken({
+	name: "Not",
+	pattern: /not/,
+	longer_alt: Identifier
+});
+const Null = createToken({
+	name: "Null",
+	pattern: /null/,
+	longer_alt: Identifier
+});
+const As = createToken({
+	name: "As",
+	pattern: /as/,
+	longer_alt: Identifier
+});
+const Include = createToken({
+	name: "Include",
+	pattern: /include/,
+	longer_alt: Identifier
+});
+const Suffix = createToken({
+	name: "Suffix",
+	pattern: /suffix/,
+	longer_alt: Identifier
+});
+const True = createToken({
+	name: "True",
+	pattern: /true/,
+	longer_alt: Identifier
+});
+const False = createToken({
+	name: "False",
+	pattern: /false/,
+	longer_alt: Identifier
+});
+const Abap = createToken({
+	name: "Abap",
+	pattern: /abap/,
+	longer_alt: Identifier
+});
+const View = createToken({
+	name: "View",
+	pattern: /view/,
+	longer_alt: Identifier
+});
+const Projection = createToken({
+	name: "Projection",
+	pattern: /projection/,
+	longer_alt: Identifier
+});
+const Select = createToken({
+	name: "Select",
+	pattern: /select/,
+	longer_alt: Identifier
+});
+const From = createToken({
+	name: "From",
+	pattern: /from/,
+	longer_alt: Identifier
+});
+const On = createToken({
+	name: "On",
+	pattern: /on/,
+	longer_alt: Identifier
+});
+const Association = createToken({
+	name: "Association",
+	pattern: /association/,
+	longer_alt: Identifier
+});
+const Composition = createToken({
+	name: "Composition",
+	pattern: /composition/,
+	longer_alt: Identifier
+});
+const To = createToken({
+	name: "To",
+	pattern: /to/,
+	longer_alt: Identifier
+});
+const Many = createToken({
+	name: "Many",
+	pattern: /many/,
+	longer_alt: Identifier
+});
+const One = createToken({
+	name: "One",
+	pattern: /one/,
+	longer_alt: Identifier
+});
+const Of = createToken({
+	name: "Of",
+	pattern: /of/,
+	longer_alt: Identifier
+});
+const Parameters = createToken({
+	name: "Parameters",
+	pattern: /parameters/,
+	longer_alt: Identifier
+});
+const Role = createToken({
+	name: "Role",
+	pattern: /role/,
+	longer_alt: Identifier
+});
+const Grant = createToken({
+	name: "Grant",
+	pattern: /grant/,
+	longer_alt: Identifier
+});
+const Where = createToken({
+	name: "Where",
+	pattern: /where/,
+	longer_alt: Identifier
+});
+const Abstract = createToken({
+	name: "Abstract",
+	pattern: /abstract/,
+	longer_alt: Identifier
+});
+const Custom = createToken({
+	name: "Custom",
+	pattern: /custom/,
+	longer_alt: Identifier
+});
+const Virtual = createToken({
+	name: "Virtual",
+	pattern: /virtual/,
+	longer_alt: Identifier
+});
+const Redirected = createToken({
+	name: "Redirected",
+	pattern: /redirected/,
+	longer_alt: Identifier
+});
+const Default = createToken({
+	name: "Default",
+	pattern: /default/,
+	longer_alt: Identifier
+});
+const EqEq = createToken({
+	name: "EqEq",
+	pattern: /==/
+});
+const Eq = createToken({
+	name: "Eq",
+	pattern: /=/
+});
+const NotEq = createToken({
+	name: "NotEq",
+	pattern: /!=|<>/
+});
+const LtEq = createToken({
+	name: "LtEq",
+	pattern: /<=/
+});
+const GtEq = createToken({
+	name: "GtEq",
+	pattern: />=/
+});
+const Lt = createToken({
+	name: "Lt",
+	pattern: /</
+});
+const Gt = createToken({
+	name: "Gt",
+	pattern: />/
+});
+const And = createToken({
+	name: "And",
+	pattern: /and/,
+	longer_alt: Identifier
+});
+const Or = createToken({
+	name: "Or",
+	pattern: /or/,
+	longer_alt: Identifier
+});
+const At = createToken({
+	name: "At",
+	pattern: /@/
+});
+const Colon = createToken({
+	name: "Colon",
+	pattern: /:/
+});
+const Semicolon = createToken({
+	name: "Semicolon",
+	pattern: /;/
+});
+const Dot = createToken({
+	name: "Dot",
+	pattern: /\./
+});
+const Comma = createToken({
+	name: "Comma",
+	pattern: /,/
+});
+const LBrace = createToken({
+	name: "LBrace",
+	pattern: /\{/
+});
+const RBrace = createToken({
+	name: "RBrace",
+	pattern: /\}/
+});
+const LParen = createToken({
+	name: "LParen",
+	pattern: /\(/
+});
+const RParen = createToken({
+	name: "RParen",
+	pattern: /\)/
+});
+const LBracket = createToken({
+	name: "LBracket",
+	pattern: /\[/
+});
+const RBracket = createToken({
+	name: "RBracket",
+	pattern: /\]/
+});
+const Star = createToken({
+	name: "Star",
+	pattern: /\*/
+});
+const Plus = createToken({
+	name: "Plus",
+	pattern: /\+/
+});
+const Minus = createToken({
+	name: "Minus",
+	pattern: /-/
+});
+const Slash = createToken({
+	name: "Slash",
+	pattern: /\//
+});
+const allTokens = [
+	WhiteSpace,
+	LineComment,
+	BlockComment,
+	StringLiteral,
+	NumberLiteral,
+	EnumLiteral,
+	Association,
+	Composition,
+	Abstract,
+	Annotate,
+	Define,
+	Table,
+	Structure,
+	Type,
+	Service,
+	Expose,
+	Entity,
+	With,
+	Key,
+	Not,
+	Null,
+	As,
+	Include,
+	Suffix,
+	True,
+	False,
+	Abap,
+	One,
+	View,
+	Projection,
+	Select,
+	From,
+	On,
+	To,
+	Many,
+	Of,
+	Parameters,
+	Role,
+	Grant,
+	Where,
+	Custom,
+	Virtual,
+	Redirected,
+	Default,
+	And,
+	Or,
+	Identifier,
+	EqEq,
+	NotEq,
+	LtEq,
+	GtEq,
+	At,
+	Colon,
+	Semicolon,
+	Dot,
+	Comma,
+	LBrace,
+	RBrace,
+	LParen,
+	RParen,
+	LBracket,
+	RBracket,
+	Eq,
+	Lt,
+	Gt,
+	Star,
+	Plus,
+	Minus,
+	Slash
+];
+const CdsLexer = new Lexer(allTokens);
+
+//#endregion
+//#region src/parser.ts
+/**
+* Chevrotain CstParser for ABAP CDS.
+*
+* Grammar coverage (see src/lib/grammar/*.ts for the per-topic index):
+*   - DDL  : table, structure, simple type, view entity, projection view,
+*            abstract/custom entity
+*   - DCL  : role definitions (grant select on ... where ...)
+*   - DDLX : metadata extensions (`annotate entity ... with { ... }`)
+*   - SRVD : service definitions (`define service ... { expose ...; }`)
+*   - Elements / associations / parameters / annotations
+*
+* Rules are kept in this single class (Chevrotain requirement). Logical
+* groupings are delimited with section banners and documented in
+* `src/lib/grammar/`.
+*/
+var CdsParser = class extends CstParser {
+	constructor() {
+		super(allTokens, {
+			recoveryEnabled: true,
+			maxLookahead: 4
+		});
+		this.performSelfAnalysis();
+	}
+	sourceFile = this.RULE("sourceFile", () => {
+		this.MANY(() => {
+			this.SUBRULE(this.topLevelAnnotation);
+		});
+		this.SUBRULE(this.definition);
+	});
+	definition = this.RULE("definition", () => {
+		this.OR([{ ALT: () => this.SUBRULE(this.defineStatement) }, { ALT: () => this.SUBRULE(this.annotateStatement) }]);
+	});
+	defineStatement = this.RULE("defineStatement", () => {
+		this.CONSUME(Define);
+		this.OR([
+			{ ALT: () => this.SUBRULE(this.tableDefinition) },
+			{ ALT: () => this.SUBRULE(this.structureDefinition) },
+			{ ALT: () => this.SUBRULE(this.viewEntityDefinition) },
+			{ ALT: () => this.SUBRULE(this.abstractEntityDefinition) },
+			{ ALT: () => this.SUBRULE(this.customEntityDefinition) },
+			{ ALT: () => this.SUBRULE(this.simpleTypeDefinition) },
+			{ ALT: () => this.SUBRULE(this.serviceDefinition) },
+			{ ALT: () => this.SUBRULE(this.roleDefinition) }
+		]);
+	});
+	tableDefinition = this.RULE("tableDefinition", () => {
+		this.CONSUME(Table);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.tableMember);
+		});
+		this.CONSUME(RBrace);
+	});
+	structureDefinition = this.RULE("structureDefinition", () => {
+		this.CONSUME(Structure);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.tableMember);
+		});
+		this.CONSUME(RBrace);
+	});
+	viewEntityDefinition = this.RULE("viewEntityDefinition", () => {
+		this.CONSUME(View);
+		this.CONSUME(Entity);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.SUBRULE(this.parametersClause);
+		});
+		this.CONSUME(As);
+		this.OR([{ ALT: () => this.SUBRULE(this.selectFromClause) }, { ALT: () => this.SUBRULE(this.projectionOnClause) }]);
+		this.OPTION2(() => {
+			this.SUBRULE(this.elementList);
+		});
+		this.OPTION3(() => {
+			this.CONSUME(Where);
+			this.SUBRULE(this.expression);
+		});
+	});
+	abstractEntityDefinition = this.RULE("abstractEntityDefinition", () => {
+		this.CONSUME(Abstract);
+		this.CONSUME(Entity);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.SUBRULE(this.parametersClause);
+		});
+		this.SUBRULE(this.elementList);
+	});
+	customEntityDefinition = this.RULE("customEntityDefinition", () => {
+		this.CONSUME(Custom);
+		this.CONSUME(Entity);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.SUBRULE(this.parametersClause);
+		});
+		this.SUBRULE(this.elementList);
+	});
+	selectFromClause = this.RULE("selectFromClause", () => {
+		this.CONSUME(Select);
+		this.OPTION(() => {
+			this.CONSUME(From);
+		});
+		this.SUBRULE(this.dataSource);
+	});
+	projectionOnClause = this.RULE("projectionOnClause", () => {
+		this.CONSUME(Projection);
+		this.CONSUME(On);
+		this.SUBRULE(this.dataSource);
+	});
+	dataSource = this.RULE("dataSource", () => {
+		this.SUBRULE(this.qualifiedName);
+		this.OPTION(() => {
+			this.OPTION2(() => this.CONSUME(As));
+			this.SUBRULE(this.cdsName);
+		});
+	});
+	elementList = this.RULE("elementList", () => {
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.elementMember);
+		});
+		this.CONSUME(RBrace);
+	});
+	elementMember = this.RULE("elementMember", () => {
+		this.MANY(() => this.SUBRULE(this.annotation));
+		this.OR([{ ALT: () => this.SUBRULE(this.associationTail) }, { ALT: () => this.SUBRULE(this.viewElementTail) }]);
+	});
+	viewElementTail = this.RULE("viewElementTail", () => {
+		this.OPTION(() => this.CONSUME(Key));
+		this.OPTION2(() => this.CONSUME(Virtual));
+		this.OPTION3(() => this.CONSUME(Redirected));
+		this.OR([{
+			GATE: () => this.isTypedField(),
+			ALT: () => this.SUBRULE(this.typedFieldTail)
+		}, { ALT: () => this.SUBRULE(this.projectionExpression) }]);
+		this.OPTION4(() => {
+			this.OR2([{ ALT: () => this.CONSUME(Semicolon) }, { ALT: () => this.CONSUME(Comma) }]);
+		});
+	});
+	typedFieldTail = this.RULE("typedFieldTail", () => {
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(Colon);
+		this.SUBRULE(this.typeReference);
+		this.OPTION(() => {
+			this.CONSUME(Not);
+			this.CONSUME(Null);
+		});
+	});
+	/**
+	* projection expression:
+	*    <qualified-name> [as <alias>]
+	* Kept intentionally narrow — full SQL expression support is out of scope.
+	*/
+	projectionExpression = this.RULE("projectionExpression", () => {
+		this.SUBRULE(this.qualifiedName);
+		this.OPTION(() => {
+			this.CONSUME(As);
+			this.SUBRULE(this.cdsName);
+		});
+	});
+	/** Cheap lookahead: `ident :` (optionally following `key`/`virtual`) → typed field. */
+	isTypedField() {
+		const first = this.LA(1);
+		const second = this.LA(2);
+		if (!first || !second) return false;
+		return (first.tokenType?.name === "Identifier" || false) && second.tokenType?.name === "Colon";
+	}
+	associationTail = this.RULE("associationTail", () => {
+		this.OR([{ ALT: () => this.CONSUME(Association) }, { ALT: () => this.CONSUME(Composition) }]);
+		this.OPTION(() => this.SUBRULE(this.cardinality));
+		this.OR2([{ ALT: () => {
+			this.CONSUME(To);
+			this.OPTION2(() => {
+				this.CONSUME(Redirected);
+				this.CONSUME2(To);
+			});
+		} }, { ALT: () => {
+			this.CONSUME(Of);
+			this.OPTION3(() => {
+				this.OR3([{ ALT: () => this.CONSUME(Many) }, { ALT: () => this.CONSUME(One) }]);
+			});
+			this.OPTION4(() => this.CONSUME3(To));
+		} }]);
+		this.SUBRULE(this.qualifiedName);
+		this.OPTION5(() => {
+			this.CONSUME(As);
+			this.SUBRULE(this.cdsName);
+		});
+		this.OPTION6(() => {
+			this.CONSUME(On);
+			this.SUBRULE(this.expression);
+		});
+		this.OPTION7(() => {
+			this.OR4([{ ALT: () => this.CONSUME(Semicolon) }, { ALT: () => this.CONSUME(Comma) }]);
+		});
+	});
+	/** `[<lower>..<upper>]`, `[<n>]`, `[*]`, `[<lower>..*]` */
+	cardinality = this.RULE("cardinality", () => {
+		this.CONSUME(LBracket);
+		this.OR([{ ALT: () => this.CONSUME(Star) }, { ALT: () => {
+			this.CONSUME(NumberLiteral);
+			this.OPTION(() => {
+				this.CONSUME(Dot);
+				this.CONSUME2(Dot);
+				this.OR2([{ ALT: () => this.CONSUME2(NumberLiteral) }, { ALT: () => this.CONSUME2(Star) }]);
+			});
+		} }]);
+		this.CONSUME(RBracket);
+	});
+	parametersClause = this.RULE("parametersClause", () => {
+		this.CONSUME(With);
+		this.CONSUME(Parameters);
+		this.SUBRULE(this.parameterDefinition);
+		this.MANY(() => {
+			this.CONSUME(Comma);
+			this.SUBRULE2(this.parameterDefinition);
+		});
+	});
+	parameterDefinition = this.RULE("parameterDefinition", () => {
+		this.MANY(() => this.SUBRULE(this.annotation));
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(Colon);
+		this.SUBRULE(this.typeReference);
+		this.OPTION(() => {
+			this.CONSUME(Default);
+			this.SUBRULE(this.literal);
+		});
+	});
+	simpleTypeDefinition = this.RULE("simpleTypeDefinition", () => {
+		this.CONSUME(Type);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(Colon);
+		this.SUBRULE(this.typeReference);
+		this.CONSUME(Semicolon);
+	});
+	serviceDefinition = this.RULE("serviceDefinition", () => {
+		this.CONSUME(Service);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.exposeStatement);
+		});
+		this.CONSUME(RBrace);
+	});
+	exposeStatement = this.RULE("exposeStatement", () => {
+		this.CONSUME(Expose);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.CONSUME(As);
+			this.SUBRULE2(this.cdsName);
+		});
+		this.CONSUME(Semicolon);
+	});
+	roleDefinition = this.RULE("roleDefinition", () => {
+		this.CONSUME(Role);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.grantStatement);
+		});
+		this.CONSUME(RBrace);
+	});
+	grantStatement = this.RULE("grantStatement", () => {
+		this.CONSUME(Grant);
+		this.CONSUME(Select);
+		this.CONSUME(On);
+		this.SUBRULE(this.qualifiedName);
+		this.OPTION(() => {
+			this.CONSUME(Where);
+			this.SUBRULE(this.expression);
+		});
+		this.CONSUME(Semicolon);
+	});
+	tableMember = this.RULE("tableMember", () => {
+		this.OR([{ ALT: () => this.SUBRULE(this.includeDirective) }, { ALT: () => this.SUBRULE(this.fieldDefinition) }]);
+	});
+	includeDirective = this.RULE("includeDirective", () => {
+		this.CONSUME(Include);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.CONSUME(With);
+			this.CONSUME(Suffix);
+			this.SUBRULE2(this.cdsName);
+		});
+		this.CONSUME(Semicolon);
+	});
+	fieldDefinition = this.RULE("fieldDefinition", () => {
+		this.MANY(() => {
+			this.SUBRULE(this.annotation);
+		});
+		this.OPTION(() => {
+			this.CONSUME(Key);
+		});
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(Colon);
+		this.SUBRULE(this.typeReference);
+		this.OPTION2(() => {
+			this.CONSUME(Not);
+			this.CONSUME(Null);
+		});
+		this.CONSUME(Semicolon);
+	});
+	annotateStatement = this.RULE("annotateStatement", () => {
+		this.CONSUME(Annotate);
+		this.CONSUME(Entity);
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(With);
+		this.CONSUME(LBrace);
+		this.MANY(() => {
+			this.SUBRULE(this.annotatedElement);
+		});
+		this.CONSUME(RBrace);
+	});
+	annotatedElement = this.RULE("annotatedElement", () => {
+		this.MANY(() => {
+			this.SUBRULE(this.annotation);
+		});
+		this.SUBRULE(this.cdsName);
+		this.CONSUME(Semicolon);
+	});
+	topLevelAnnotation = this.RULE("topLevelAnnotation", () => {
+		this.SUBRULE(this.annotation);
+	});
+	annotation = this.RULE("annotation", () => {
+		this.CONSUME(At);
+		this.SUBRULE(this.dottedName);
+		this.OPTION(() => {
+			this.CONSUME(Colon);
+			this.SUBRULE(this.annotationValue);
+		});
+	});
+	dottedName = this.RULE("dottedName", () => {
+		this.SUBRULE(this.cdsName);
+		this.MANY(() => {
+			this.CONSUME(Dot);
+			this.SUBRULE2(this.cdsName);
+		});
+	});
+	annotationValue = this.RULE("annotationValue", () => {
+		this.OR([
+			{ ALT: () => this.CONSUME(StringLiteral) },
+			{ ALT: () => this.CONSUME(EnumLiteral) },
+			{ ALT: () => this.CONSUME(True) },
+			{ ALT: () => this.CONSUME(False) },
+			{ ALT: () => this.CONSUME(NumberLiteral) },
+			{ ALT: () => this.SUBRULE(this.annotationArray) },
+			{ ALT: () => this.SUBRULE(this.annotationObject) }
+		]);
+	});
+	annotationArray = this.RULE("annotationArray", () => {
+		this.CONSUME(LBracket);
+		this.MANY_SEP({
+			SEP: Comma,
+			DEF: () => {
+				this.SUBRULE(this.annotationValue);
+			}
+		});
+		this.CONSUME(RBracket);
+	});
+	annotationObject = this.RULE("annotationObject", () => {
+		this.CONSUME(LBrace);
+		this.MANY_SEP({
+			SEP: Comma,
+			DEF: () => {
+				this.SUBRULE(this.annotationProperty);
+			}
+		});
+		this.CONSUME(RBrace);
+	});
+	annotationProperty = this.RULE("annotationProperty", () => {
+		this.SUBRULE(this.dottedName);
+		this.CONSUME(Colon);
+		this.SUBRULE(this.annotationValue);
+	});
+	literal = this.RULE("literal", () => {
+		this.OR([
+			{ ALT: () => this.CONSUME(StringLiteral) },
+			{ ALT: () => this.CONSUME(NumberLiteral) },
+			{ ALT: () => this.CONSUME(EnumLiteral) },
+			{ ALT: () => this.CONSUME(True) },
+			{ ALT: () => this.CONSUME(False) }
+		]);
+	});
+	expression = this.RULE("expression", () => {
+		this.SUBRULE(this.comparison);
+		this.MANY(() => {
+			this.OR([{ ALT: () => this.CONSUME(And) }, { ALT: () => this.CONSUME(Or) }]);
+			this.SUBRULE2(this.comparison);
+		});
+	});
+	comparison = this.RULE("comparison", () => {
+		this.SUBRULE(this.operand);
+		this.OPTION(() => {
+			this.OR([
+				{ ALT: () => this.CONSUME(EqEq) },
+				{ ALT: () => this.CONSUME(Eq) },
+				{ ALT: () => this.CONSUME(NotEq) },
+				{ ALT: () => this.CONSUME(LtEq) },
+				{ ALT: () => this.CONSUME(GtEq) },
+				{ ALT: () => this.CONSUME(Lt) },
+				{ ALT: () => this.CONSUME(Gt) }
+			]);
+			this.SUBRULE2(this.operand);
+		});
+	});
+	operand = this.RULE("operand", () => {
+		this.OR([{ ALT: () => this.SUBRULE(this.literal) }, { ALT: () => this.SUBRULE(this.qualifiedName) }]);
+	});
+	typeReference = this.RULE("typeReference", () => {
+		this.OR([{ ALT: () => this.SUBRULE(this.builtinType) }, { ALT: () => this.SUBRULE(this.namedType) }]);
+	});
+	/** `abap.char(10)` or `abap.dec(11,2)` */
+	builtinType = this.RULE("builtinType", () => {
+		this.CONSUME(Abap);
+		this.CONSUME(Dot);
+		this.SUBRULE(this.cdsName);
+		this.OPTION(() => {
+			this.CONSUME(LParen);
+			this.CONSUME(NumberLiteral);
+			this.OPTION2(() => {
+				this.CONSUME(Comma);
+				this.CONSUME2(NumberLiteral);
+			});
+			this.CONSUME(RParen);
+		});
+	});
+	/** Data element or other named type reference */
+	namedType = this.RULE("namedType", () => {
+		this.SUBRULE(this.qualifiedName);
+	});
+	/** An identifier that may also be a keyword used as a name. */
+	cdsName = this.RULE("cdsName", () => {
+		this.OR([
+			{ ALT: () => this.CONSUME(Identifier) },
+			{ ALT: () => this.CONSUME(Table) },
+			{ ALT: () => this.CONSUME(Structure) },
+			{ ALT: () => this.CONSUME(Type) },
+			{ ALT: () => this.CONSUME(Service) },
+			{ ALT: () => this.CONSUME(Entity) },
+			{ ALT: () => this.CONSUME(Key) },
+			{ ALT: () => this.CONSUME(Expose) },
+			{ ALT: () => this.CONSUME(View) },
+			{ ALT: () => this.CONSUME(Role) },
+			{ ALT: () => this.CONSUME(Association) },
+			{ ALT: () => this.CONSUME(Composition) },
+			{ ALT: () => this.CONSUME(Abstract) },
+			{ ALT: () => this.CONSUME(Custom) },
+			{ ALT: () => this.CONSUME(Virtual) },
+			{ ALT: () => this.CONSUME(Redirected) },
+			{ ALT: () => this.CONSUME(Default) },
+			{ ALT: () => this.CONSUME(Parameters) },
+			{ ALT: () => this.CONSUME(Grant) },
+			{ ALT: () => this.CONSUME(Many) },
+			{ ALT: () => this.CONSUME(One) },
+			{ ALT: () => this.CONSUME(Of) },
+			{ ALT: () => this.CONSUME(Projection) },
+			{ ALT: () => this.CONSUME(Select) },
+			{ ALT: () => this.CONSUME(From) },
+			{ ALT: () => this.CONSUME(To) },
+			{ ALT: () => this.CONSUME(Where) }
+		]);
+	});
+	/** Dot-separated qualified name: foo.bar.baz */
+	qualifiedName = this.RULE("qualifiedName", () => {
+		this.SUBRULE(this.cdsName);
+		this.MANY(() => {
+			this.CONSUME(Dot);
+			this.SUBRULE2(this.cdsName);
+		});
+	});
+};
+/** Singleton parser instance (Chevrotain parsers are reusable) */
+const cdsParser = new CdsParser();
+
+//#endregion
+//#region src/visitor.ts
+const BaseCstVisitor = cdsParser.getBaseCstVisitorConstructor();
+function asNodes(v) {
+	return v ?? [];
+}
+function asTokens(v) {
+	return v ?? [];
+}
+function collectTokenImages(node) {
+	if (!node) return [];
+	const out = [];
+	const walk = (n) => {
+		for (const children of Object.values(n.children)) for (const child of children) if ("tokenType" in child) out.push(child);
+		else walk(child);
+	};
+	walk(node);
+	out.sort((a, b) => (a.startOffset ?? 0) - (b.startOffset ?? 0));
+	return out;
+}
+function toExpression(node) {
+	const toks = collectTokenImages(node);
+	return {
+		source: toks.map((t) => t.image).join(" "),
+		tokens: toks.map((t) => t.image)
+	};
+}
+var CdsVisitor = class extends BaseCstVisitor {
+	constructor() {
+		super();
+		this.validateVisitor();
+	}
+	sourceFile(ctx) {
+		const annotations = asNodes(ctx.topLevelAnnotation).map((node) => this.visit(node));
+		const def = this.visit(asNodes(ctx.definition)[0]);
+		if ("annotations" in def) def.annotations = [...annotations, ...def.annotations];
+		return { definitions: [def] };
+	}
+	definition(ctx) {
+		if (ctx.defineStatement) return this.visit(asNodes(ctx.defineStatement)[0]);
+		return this.visit(asNodes(ctx.annotateStatement)[0]);
+	}
+	defineStatement(ctx) {
+		const dispatch = [
+			["tableDefinition", asNodes(ctx.tableDefinition)[0]],
+			["structureDefinition", asNodes(ctx.structureDefinition)[0]],
+			["viewEntityDefinition", asNodes(ctx.viewEntityDefinition)[0]],
+			["abstractEntityDefinition", asNodes(ctx.abstractEntityDefinition)[0]],
+			["customEntityDefinition", asNodes(ctx.customEntityDefinition)[0]],
+			["simpleTypeDefinition", asNodes(ctx.simpleTypeDefinition)[0]],
+			["serviceDefinition", asNodes(ctx.serviceDefinition)[0]],
+			["roleDefinition", asNodes(ctx.roleDefinition)[0]]
+		];
+		for (const [, node] of dispatch) if (node) return this.visit(node);
+		return {
+			kind: "table",
+			name: "",
+			annotations: [],
+			members: []
+		};
+	}
+	tableDefinition(ctx) {
+		return {
+			kind: "table",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			members: asNodes(ctx.tableMember).map((node) => this.visit(node))
+		};
+	}
+	structureDefinition(ctx) {
+		return {
+			kind: "structure",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			members: asNodes(ctx.tableMember).map((node) => this.visit(node))
+		};
+	}
+	viewEntityDefinition(ctx) {
+		const name = this.visit(asNodes(ctx.cdsName)[0]);
+		const parameters = ctx.parametersClause ? this.visit(asNodes(ctx.parametersClause)[0]) : [];
+		let sourceKind = "select";
+		let source = { name: "" };
+		if (ctx.selectFromClause) {
+			sourceKind = "select";
+			source = this.visit(asNodes(ctx.selectFromClause)[0]);
+		} else if (ctx.projectionOnClause) {
+			sourceKind = "projection";
+			source = this.visit(asNodes(ctx.projectionOnClause)[0]);
+		}
+		const members = ctx.elementList ? this.visit(asNodes(ctx.elementList)[0]) : [];
+		const where = ctx.expression ? toExpression(asNodes(ctx.expression)[0]) : void 0;
+		return {
+			kind: "viewEntity",
+			name,
+			annotations: [],
+			sourceKind,
+			source,
+			parameters,
+			members,
+			...where && { where }
+		};
+	}
+	abstractEntityDefinition(ctx) {
+		return {
+			kind: "abstractEntity",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			parameters: ctx.parametersClause ? this.visit(asNodes(ctx.parametersClause)[0]) : [],
+			members: this.visit(asNodes(ctx.elementList)[0])
+		};
+	}
+	customEntityDefinition(ctx) {
+		return {
+			kind: "customEntity",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			parameters: ctx.parametersClause ? this.visit(asNodes(ctx.parametersClause)[0]) : [],
+			members: this.visit(asNodes(ctx.elementList)[0])
+		};
+	}
+	selectFromClause(ctx) {
+		return this.visit(asNodes(ctx.dataSource)[0]);
+	}
+	projectionOnClause(ctx) {
+		return this.visit(asNodes(ctx.dataSource)[0]);
+	}
+	dataSource(ctx) {
+		const name = this.visit(asNodes(ctx.qualifiedName)[0]);
+		const aliasNode = asNodes(ctx.cdsName)[0];
+		const alias = aliasNode ? this.visit(aliasNode) : void 0;
+		return {
+			name,
+			...alias && { alias }
+		};
+	}
+	elementList(ctx) {
+		return asNodes(ctx.elementMember).map((node) => this.visit(node));
+	}
+	elementMember(ctx) {
+		const annotations = asNodes(ctx.annotation).map((n) => this.visit(n));
+		if (ctx.associationTail) {
+			const decl = this.visit(asNodes(ctx.associationTail)[0]);
+			decl.annotations = annotations;
+			return decl;
+		}
+		const el = this.visit(asNodes(ctx.viewElementTail)[0]);
+		el.annotations = annotations;
+		return el;
+	}
+	viewElementTail(ctx) {
+		const isKey = !!asTokens(ctx.Key).length;
+		const isVirtual = !!asTokens(ctx.Virtual).length;
+		const isRedirected = !!asTokens(ctx.Redirected).length;
+		if (ctx.typedFieldTail) {
+			const tail = this.visit(asNodes(ctx.typedFieldTail)[0]);
+			return {
+				annotations: [],
+				isKey,
+				isVirtual,
+				isRedirected,
+				expression: tail.name,
+				type: tail.type,
+				notNull: tail.notNull
+			};
+		}
+		const proj = this.visit(asNodes(ctx.projectionExpression)[0]);
+		return {
+			annotations: [],
+			isKey,
+			isVirtual,
+			isRedirected,
+			expression: proj.expression,
+			...proj.alias && { alias: proj.alias }
+		};
+	}
+	typedFieldTail(ctx) {
+		return {
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			type: this.visit(asNodes(ctx.typeReference)[0]),
+			notNull: !!asTokens(ctx.Not).length
+		};
+	}
+	projectionExpression(ctx) {
+		const expression = this.visit(asNodes(ctx.qualifiedName)[0]);
+		const aliasNode = asNodes(ctx.cdsName)[0];
+		const alias = aliasNode ? this.visit(aliasNode) : void 0;
+		return {
+			expression,
+			...alias && { alias }
+		};
+	}
+	associationTail(ctx) {
+		const associationKind = asTokens(ctx.Association).length ? "association" : "composition";
+		const cardinality = ctx.cardinality ? this.visit(asNodes(ctx.cardinality)[0]) : void 0;
+		let targetMultiplicity;
+		if (asTokens(ctx.Many).length) targetMultiplicity = "many";
+		else if (asTokens(ctx.One).length) targetMultiplicity = "one";
+		const redirected = !!asTokens(ctx.Redirected).length;
+		const target = this.visit(asNodes(ctx.qualifiedName)[0]);
+		const aliasNode = asNodes(ctx.cdsName)[0];
+		const alias = aliasNode ? this.visit(aliasNode) : void 0;
+		const on = ctx.expression ? toExpression(asNodes(ctx.expression)[0]) : void 0;
+		return {
+			kind: "association",
+			associationKind,
+			annotations: [],
+			...cardinality && { cardinality },
+			...targetMultiplicity && { targetMultiplicity },
+			target,
+			...redirected && { redirected: true },
+			...alias && { alias },
+			...on && { on }
+		};
+	}
+	cardinality(ctx) {
+		const nums = asTokens(ctx.NumberLiteral);
+		const stars = asTokens(ctx.Star);
+		if (nums.length === 0 && stars.length >= 1) return { max: "*" };
+		if (nums.length === 1) {
+			if (asTokens(ctx.Dot).length === 0) return { max: Number.parseInt(nums[0].image, 10) };
+			if (stars.length >= 1) return {
+				min: Number.parseInt(nums[0].image, 10),
+				max: "*"
+			};
+			return {
+				min: Number.parseInt(nums[0].image, 10),
+				max: "*"
+			};
+		}
+		if (nums.length === 2) return {
+			min: Number.parseInt(nums[0].image, 10),
+			max: Number.parseInt(nums[1].image, 10)
+		};
+		return { max: "*" };
+	}
+	parametersClause(ctx) {
+		return asNodes(ctx.parameterDefinition).map((n) => this.visit(n));
+	}
+	parameterDefinition(ctx) {
+		const annotations = asNodes(ctx.annotation).map((n) => this.visit(n));
+		const name = this.visit(asNodes(ctx.cdsName)[0]);
+		const type = this.visit(asNodes(ctx.typeReference)[0]);
+		const defaultValue = ctx.literal ? this.visit(asNodes(ctx.literal)[0]) : void 0;
+		return {
+			annotations,
+			name,
+			type,
+			...defaultValue && { defaultValue }
+		};
+	}
+	tableMember(ctx) {
+		if (ctx.includeDirective) return this.visit(asNodes(ctx.includeDirective)[0]);
+		return this.visit(asNodes(ctx.fieldDefinition)[0]);
+	}
+	includeDirective(ctx) {
+		const name = this.visit(asNodes(ctx.cdsName)[0]);
+		const suffix = asNodes(ctx.cdsName)[1] ? this.visit(asNodes(ctx.cdsName)[1]) : void 0;
+		return {
+			kind: "include",
+			name,
+			...suffix !== void 0 && { suffix }
+		};
+	}
+	fieldDefinition(ctx) {
+		const annotations = asNodes(ctx.annotation).map((node) => this.visit(node));
+		const isKey = !!asTokens(ctx.Key).length;
+		return {
+			annotations,
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			type: this.visit(asNodes(ctx.typeReference)[0]),
+			isKey,
+			notNull: !!asTokens(ctx.Not).length
+		};
+	}
+	simpleTypeDefinition(ctx) {
+		return {
+			kind: "simpleType",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			type: this.visit(asNodes(ctx.typeReference)[0])
+		};
+	}
+	serviceDefinition(ctx) {
+		return {
+			kind: "service",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			exposes: asNodes(ctx.exposeStatement).map((node) => this.visit(node))
+		};
+	}
+	exposeStatement(ctx) {
+		const names = asNodes(ctx.cdsName).map((n) => this.visit(n));
+		const entity = names[0];
+		const alias = names.length > 1 ? names[1] : void 0;
+		return {
+			entity,
+			...alias && { alias }
+		};
+	}
+	roleDefinition(ctx) {
+		return {
+			kind: "role",
+			name: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			grants: asNodes(ctx.grantStatement).map((n) => this.visit(n))
+		};
+	}
+	grantStatement(ctx) {
+		const entity = this.visit(asNodes(ctx.qualifiedName)[0]);
+		const where = ctx.expression ? toExpression(asNodes(ctx.expression)[0]) : void 0;
+		return {
+			privilege: "select",
+			entity,
+			...where && { where }
+		};
+	}
+	annotateStatement(ctx) {
+		return {
+			kind: "metadataExtension",
+			entity: this.visit(asNodes(ctx.cdsName)[0]),
+			annotations: [],
+			elements: asNodes(ctx.annotatedElement).map((node) => this.visit(node))
+		};
+	}
+	annotatedElement(ctx) {
+		return {
+			annotations: asNodes(ctx.annotation).map((node) => this.visit(node)),
+			name: this.visit(asNodes(ctx.cdsName)[0])
+		};
+	}
+	topLevelAnnotation(ctx) {
+		return this.visit(asNodes(ctx.annotation)[0]);
+	}
+	annotation(ctx) {
+		return {
+			key: this.visit(asNodes(ctx.dottedName)[0]),
+			value: ctx.annotationValue ? this.visit(asNodes(ctx.annotationValue)[0]) : {
+				kind: "boolean",
+				value: true
+			}
+		};
+	}
+	dottedName(ctx) {
+		return asNodes(ctx.cdsName).map((node) => this.visit(node)).join(".");
+	}
+	annotationValue(ctx) {
+		if (ctx.StringLiteral) return {
+			kind: "string",
+			value: asTokens(ctx.StringLiteral)[0].image.slice(1, -1)
+		};
+		if (ctx.EnumLiteral) return {
+			kind: "enum",
+			value: asTokens(ctx.EnumLiteral)[0].image.slice(1)
+		};
+		if (ctx.True) return {
+			kind: "boolean",
+			value: true
+		};
+		if (ctx.False) return {
+			kind: "boolean",
+			value: false
+		};
+		if (ctx.NumberLiteral) return {
+			kind: "number",
+			value: parseFloat(asTokens(ctx.NumberLiteral)[0].image)
+		};
+		if (ctx.annotationArray) return this.visit(asNodes(ctx.annotationArray)[0]);
+		return this.visit(asNodes(ctx.annotationObject)[0]);
+	}
+	annotationArray(ctx) {
+		return {
+			kind: "array",
+			items: asNodes(ctx.annotationValue).map((node) => this.visit(node))
+		};
+	}
+	annotationObject(ctx) {
+		return {
+			kind: "object",
+			properties: asNodes(ctx.annotationProperty).map((node) => this.visit(node))
+		};
+	}
+	annotationProperty(ctx) {
+		return {
+			key: this.visit(asNodes(ctx.dottedName)[0]),
+			value: this.visit(asNodes(ctx.annotationValue)[0])
+		};
+	}
+	literal(ctx) {
+		if (ctx.StringLiteral) return {
+			kind: "string",
+			value: asTokens(ctx.StringLiteral)[0].image.slice(1, -1)
+		};
+		if (ctx.EnumLiteral) return {
+			kind: "enum",
+			value: asTokens(ctx.EnumLiteral)[0].image.slice(1)
+		};
+		if (ctx.True) return {
+			kind: "boolean",
+			value: true
+		};
+		if (ctx.False) return {
+			kind: "boolean",
+			value: false
+		};
+		return {
+			kind: "number",
+			value: parseFloat(asTokens(ctx.NumberLiteral)[0].image)
+		};
+	}
+	expression() {
+		return null;
+	}
+	comparison() {
+		return null;
+	}
+	operand() {
+		return null;
+	}
+	typeReference(ctx) {
+		if (ctx.builtinType) return this.visit(asNodes(ctx.builtinType)[0]);
+		return this.visit(asNodes(ctx.namedType)[0]);
+	}
+	builtinType(ctx) {
+		const name = this.visit(asNodes(ctx.cdsName)[0]);
+		const numberTokens = asTokens(ctx.NumberLiteral);
+		return {
+			kind: "builtin",
+			name,
+			length: numberTokens[0] ? Number.parseInt(numberTokens[0].image, 10) : void 0,
+			decimals: numberTokens[1] ? Number.parseInt(numberTokens[1].image, 10) : void 0
+		};
+	}
+	namedType(ctx) {
+		return {
+			kind: "named",
+			name: this.visit(asNodes(ctx.qualifiedName)[0])
+		};
+	}
+	cdsName(ctx) {
+		const t = ctx;
+		for (const key of Object.keys(t)) {
+			const tok = t[key]?.[0];
+			if (tok && "image" in tok) return tok.image;
+		}
+		return "";
+	}
+	qualifiedName(ctx) {
+		return asNodes(ctx.cdsName).map((node) => this.visit(node)).join(".");
+	}
+};
+/** Singleton visitor instance */
+const cdsVisitor = new CdsVisitor();
+
+//#endregion
+//#region src/errors.ts
+function fromLexError(err) {
+	return {
+		message: err.message,
+		line: err.line ?? 1,
+		column: err.column ?? 1,
+		offset: err.offset,
+		length: err.length
+	};
+}
+function fromParseError(err) {
+	const token = err.token;
+	return {
+		message: err.message,
+		line: token.startLine ?? 1,
+		column: token.startColumn ?? 1,
+		offset: token.startOffset,
+		length: (token.endOffset ?? token.startOffset) - token.startOffset + 1
+	};
+}
+
+//#endregion
+//#region src/lib/ast/walker.ts
+/** True when the definition has a `members` array (view-like entities). */
+function hasMembers(def) {
+	return def.kind === "viewEntity" || def.kind === "abstractEntity" || def.kind === "customEntity";
+}
+/** True when the definition has a `members` array of typed fields (TABL/structure). */
+function hasFields(def) {
+	return def.kind === "table" || def.kind === "structure";
+}
+function hasParameters(def) {
+	return def.kind === "viewEntity" || def.kind === "abstractEntity" || def.kind === "customEntity";
+}
+/** Yield every definition in the file (currently one, future-proofed). */
+function* walkDefinitions(file) {
+	for (const def of file.definitions) yield def;
+}
+/**
+* Yield every annotation attached anywhere in the AST (definitions,
+* elements/fields, parameters, associations).
+*/
+function* walkAnnotations(file) {
+	for (const def of walkDefinitions(file)) {
+		for (const a of getAnnotations(def)) yield a;
+		if (hasFields(def)) {
+			for (const m of def.members) if ("annotations" in m) for (const a of m.annotations) yield a;
+		}
+		if (hasMembers(def)) for (const m of def.members) for (const a of m.annotations) yield a;
+		if (hasParameters(def)) for (const p of def.parameters) for (const a of p.annotations) yield a;
+	}
+}
+/** Safe accessor — returns an empty array if the definition carries none. */
+function getAnnotations(def) {
+	return "annotations" in def ? def.annotations : [];
+}
+/** Yield every element (`ViewElement`) across all view-like definitions. */
+function* walkViewElements(file) {
+	for (const def of walkDefinitions(file)) {
+		if (!hasMembers(def)) continue;
+		for (const m of def.members) {
+			if (isAssociation(m)) continue;
+			yield {
+				owner: def,
+				element: m
+			};
+		}
+	}
+}
+/** Yield every association declaration across view-like definitions. */
+function* walkAssociations(file) {
+	for (const def of walkDefinitions(file)) {
+		if (!hasMembers(def)) continue;
+		for (const m of def.members) {
+			if (!isAssociation(m)) continue;
+			yield {
+				owner: def,
+				association: m
+			};
+		}
+	}
+}
+/** Yield every field definition from tables and structures. */
+function* walkFields(file) {
+	for (const def of walkDefinitions(file)) {
+		if (!hasFields(def)) continue;
+		for (const m of def.members) {
+			if ("kind" in m && m.kind === "include") continue;
+			yield {
+				owner: def,
+				field: m
+			};
+		}
+	}
+}
+/** Yield every parameter definition across view-like entities. */
+function* walkParameters(file) {
+	for (const def of walkDefinitions(file)) {
+		if (!hasParameters(def)) continue;
+		for (const p of def.parameters) yield {
+			owner: def,
+			parameter: p
+		};
+	}
+}
+function isAssociation(m) {
+	return "kind" in m && m.kind === "association";
+}
+/** Look up an annotation by its dotted key. Returns the first match. */
+function findAnnotation(annotations, key) {
+	return annotations.find((a) => a.key === key);
+}
+
+//#endregion
+//#region src/lib/validate/cardinality.ts
+function validateCardinality(file) {
+	const diagnostics = [];
+	for (const { association } of walkAssociations(file)) {
+		const card = association.cardinality;
+		if (!card) continue;
+		const { min, max } = card;
+		const name = association.alias ?? association.target;
+		if (min !== void 0 && min < 0) diagnostics.push({
+			code: "ACDS001",
+			severity: "error",
+			message: `Association '${name}': lower bound (${min}) must be >= 0.`,
+			target: name
+		});
+		if (typeof max === "number" && max < 1) diagnostics.push({
+			code: "ACDS002",
+			severity: "error",
+			message: `Association '${name}': upper bound (${max}) must be >= 1.`,
+			target: name
+		});
+		if (min !== void 0 && typeof max === "number" && min > max) diagnostics.push({
+			code: "ACDS003",
+			severity: "error",
+			message: `Association '${name}': lower bound (${min}) exceeds upper bound (${max}).`,
+			target: name
+		});
+	}
+	return diagnostics;
+}
+
+//#endregion
+//#region src/lib/validate/elements.ts
+function validateViewElements(file) {
+	const diagnostics = [];
+	for (const { element } of walkViewElements(file)) {
+		const name = element.alias ?? element.expression;
+		if (element.isVirtual && element.type) diagnostics.push({
+			code: "ACDS010",
+			severity: "error",
+			message: `View element '${name}' cannot be virtual and typed at the same time.`,
+			target: name
+		});
+		if (element.isKey && element.isVirtual) diagnostics.push({
+			code: "ACDS011",
+			severity: "error",
+			message: `View element '${name}' cannot be both 'key' and 'virtual'.`,
+			target: name
+		});
+	}
+	return diagnostics;
+}
+
+//#endregion
+//#region src/lib/validate/index.ts
+/** Run all validators. */
+function validate(file) {
+	return [...validateCardinality(file), ...validateViewElements(file)];
+}
+
+//#endregion
+//#region src/lib/grammar/ddl.ts
+const ddlCoverage = {
+	topic: "ddl",
+	constructs: [
+		"define table",
+		"define structure",
+		"define type",
+		"define view entity",
+		"define abstract entity",
+		"define custom entity",
+		"define service",
+		"annotate entity",
+		"include directive",
+		"builtin type (abap.char, abap.dec, ...)",
+		"named type reference"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/dcl.ts
+const dclCoverage = {
+	topic: "dcl",
+	constructs: [
+		"define role <name> { ... }",
+		"grant select on <entity>",
+		"grant select on <entity> where <expression>"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/annotations.ts
+const annotationsCoverage = {
+	topic: "annotations",
+	constructs: [
+		"@Key : value",
+		"@Key.path : value",
+		"array value",
+		"object value",
+		"nested objects",
+		"bare boolean (@Key)"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/associations.ts
+const associationsCoverage = {
+	topic: "associations",
+	constructs: [
+		"association to <target>",
+		"association[cardinality] to <target>",
+		"association[L..U] to <target>",
+		"association of (many|one) to <target>",
+		"composition to <target>",
+		"association to redirected to <target>",
+		"association ... as <alias>",
+		"association ... on <expression>"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/parameters.ts
+const parametersCoverage = {
+	topic: "parameters",
+	constructs: [
+		"with parameters <p>: <type>",
+		"with parameters <p>: <type> default <literal>",
+		"annotated parameters"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/projections.ts
+const projectionsCoverage = {
+	topic: "projections",
+	constructs: [
+		"view element (qualified name)",
+		"view element with alias",
+		"view element with key modifier",
+		"view element with virtual modifier",
+		"typed field (abstract/custom entity)",
+		"view where clause",
+		"projection view (as projection on <source>)"
+	]
+};
+
+//#endregion
+//#region src/lib/grammar/actions.ts
+const actionsCoverage = {
+	topic: "actions",
+	constructs: []
+};
+
+//#endregion
+//#region src/lib/grammar/index.ts
+const GRAMMAR_COVERAGE = [
+	ddlCoverage,
+	dclCoverage,
+	annotationsCoverage,
+	associationsCoverage,
+	parametersCoverage,
+	projectionsCoverage,
+	actionsCoverage
+];
+
+//#endregion
+//#region src/index.ts
+/**
+* @abapify/acds — ABAP CDS Source Parser
+*
+* Parses ABAP CDS DDL source (.acds) files into a typed AST.
+*
+* @example
+* ```typescript
+* import { parse } from '@abapify/acds';
+*
+* const result = parse(`
+*   @AbapCatalog.tableCategory : #TRANSPARENT
+*   define table ztable {
+*     key field1 : abap.char(10) not null;
+*     field2 : some_data_element;
+*   }
+* `);
+*
+* if (result.errors.length === 0) {
+*   const table = result.ast.definitions[0]; // TableDefinition
+* }
+* ```
+*/
+/**
+* Parse an ABAP CDS source string into a typed AST.
+*
+* @param source - The CDS source code to parse
+* @returns Parse result with AST and any errors
+*/
+function parse(source) {
+	const lexResult = CdsLexer.tokenize(source);
+	const errors = lexResult.errors.map(fromLexError);
+	cdsParser.input = lexResult.tokens;
+	const cst = cdsParser.sourceFile();
+	errors.push(...cdsParser.errors.map(fromParseError));
+	let ast = { definitions: [] };
+	if (cst) try {
+		ast = cdsVisitor.visit(cst);
+	} catch {}
+	return {
+		ast,
+		errors
+	};
+}
+
+//#endregion
+export { GRAMMAR_COVERAGE, actionsCoverage, annotationsCoverage, associationsCoverage, dclCoverage, ddlCoverage, findAnnotation, hasFields, hasMembers, hasParameters, isAssociation, parametersCoverage, parse, projectionsCoverage, validate, validateCardinality, validateViewElements, walkAnnotations, walkAssociations, walkDefinitions, walkFields, walkParameters, walkViewElements };
+//# sourceMappingURL=index.mjs.map