@claudetools/tools 0.8.10 → 0.9.0

package/dist/codedna/kappa-parser.js

@@ -0,0 +1,2547 @@
+// =============================================================================
+// Kappa v2.5 Parser (Chevrotain)
+// =============================================================================
+//
+// Parses Kappa specification language into AST nodes.
+// Uses Chevrotain's Embedded Actions pattern for direct AST construction.
+//
+// Reference: docs/research/2026-01-02-kappa-v2.5-specification.md
+//
+import { CstParser } from 'chevrotain';
+import * as tokens from './kappa-lexer.js';
+// =============================================================================
+// Parser Definition
+// =============================================================================
+class KappaParser extends CstParser {
+    constructor() {
+        super(tokens.allTokens, {
+            recoveryEnabled: true,
+        });
+        this.performSelfAnalysis();
+    }
+    // ---------------------------------------------------------------------------
+    // Root Rule
+    // ---------------------------------------------------------------------------
+    kappaSpec = this.RULE('kappaSpec', () => {
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => this.SUBRULE(this.projectBlock) },
+                { ALT: () => this.SUBRULE(this.authBlock) },
+                { ALT: () => this.SUBRULE(this.entityBlock) },
+                { ALT: () => this.SUBRULE(this.apiBlock) },
+                { ALT: () => this.SUBRULE(this.journeyBlock) },
+                { ALT: () => this.SUBRULE(this.pageBlock) },
+                { ALT: () => this.SUBRULE(this.componentBlock) },
+                { ALT: () => this.SUBRULE(this.formBlock) },
+                { ALT: () => this.SUBRULE(this.designBlock) },
+            ]);
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Project Block
+    // ---------------------------------------------------------------------------
+    projectBlock = this.RULE('projectBlock', () => {
+        this.CONSUME(tokens.Project);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.projectProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    projectProperty = this.RULE('projectProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Version);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Stack);
+                    this.CONSUME2(tokens.Colon);
+                    this.SUBRULE(this.stackValue);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Database);
+                    this.CONSUME3(tokens.Colon);
+                    this.SUBRULE(this.databaseValue);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Auth);
+                    this.CONSUME4(tokens.Colon);
+                    this.SUBRULE(this.authTypeValue);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Ui);
+                    this.CONSUME5(tokens.Colon);
+                    this.SUBRULE(this.uiValue);
+                },
+            },
+        ]);
+    });
+    stackValue = this.RULE('stackValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.TanstackStart) },
+            { ALT: () => this.CONSUME(tokens.Nextjs) },
+            { ALT: () => this.CONSUME(tokens.Remix) },
+            { ALT: () => this.CONSUME(tokens.Sveltekit) },
+            { ALT: () => this.CONSUME(tokens.Astro) },
+            { ALT: () => this.CONSUME(tokens.Express) },
+            { ALT: () => this.CONSUME(tokens.Hono) },
+            { ALT: () => this.CONSUME(tokens.Elysia) },
+        ]);
+    });
+    databaseValue = this.RULE('databaseValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Postgres) },
+            { ALT: () => this.CONSUME(tokens.Mysql) },
+            { ALT: () => this.CONSUME(tokens.Sqlite) },
+            { ALT: () => this.CONSUME(tokens.Turso) },
+            { ALT: () => this.CONSUME(tokens.Mongodb) },
+        ]);
+    });
+    authTypeValue = this.RULE('authTypeValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Jwt) },
+            { ALT: () => this.CONSUME(tokens.Session) },
+            { ALT: () => this.CONSUME(tokens.Oauth) },
+        ]);
+    });
+    uiValue = this.RULE('uiValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Shadcn) },
+            { ALT: () => this.CONSUME(tokens.Mui) },
+            { ALT: () => this.CONSUME(tokens.Chakra) },
+            { ALT: () => this.CONSUME(tokens.TailwindOnly) },
+        ]);
+    });
+    // ---------------------------------------------------------------------------
+    // Auth Block
+    // ---------------------------------------------------------------------------
+    authBlock = this.RULE('authBlock', () => {
+        this.CONSUME(tokens.Auth);
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Jwt) },
+            { ALT: () => this.CONSUME(tokens.Session) },
+        ]);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.authProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    authProperty = this.RULE('authProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Secret);
+                    this.CONSUME(tokens.Colon);
+                    this.SUBRULE(this.envCall);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Issuer);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Audience);
+                    this.CONSUME3(tokens.Colon);
+                    this.CONSUME2(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Expires);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME(tokens.DurationLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Refresh);
+                    this.CONSUME5(tokens.Colon);
+                    this.SUBRULE(this.refreshValue);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Hash);
+                    this.CONSUME6(tokens.Colon);
+                    this.SUBRULE(this.hashConfig);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Duration);
+                    this.CONSUME7(tokens.Colon);
+                    this.CONSUME2(tokens.DurationLiteral);
+                },
+            },
+        ]);
+    });
+    envCall = this.RULE('envCall', () => {
+        this.CONSUME(tokens.Env);
+        this.CONSUME(tokens.LParen);
+        // Env var names can be SCREAMING_SNAKE_CASE (ConstantIdentifier), PascalCase, or camelCase
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.ConstantIdentifier) },
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+            { ALT: () => this.CONSUME(tokens.Identifier) },
+        ]);
+        this.CONSUME(tokens.RParen);
+    });
+    refreshValue = this.RULE('refreshValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Sliding) },
+            { ALT: () => this.CONSUME(tokens.Fixed) },
+            { ALT: () => this.CONSUME(tokens.None) },
+        ]);
+    });
+    hashConfig = this.RULE('hashConfig', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Argon2id);
+                    this.CONSUME(tokens.LParen);
+                    this.SUBRULE(this.hashParams);
+                    this.CONSUME(tokens.RParen);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Bcrypt);
+                    this.OPTION(() => {
+                        this.CONSUME2(tokens.LParen);
+                        this.CONSUME(tokens.Rounds);
+                        this.CONSUME(tokens.Colon);
+                        this.CONSUME(tokens.IntegerLiteral);
+                        this.CONSUME2(tokens.RParen);
+                    });
+                },
+            },
+        ]);
+    });
+    hashParams = this.RULE('hashParams', () => {
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => {
+                this.OR([
+                    {
+                        ALT: () => {
+                            this.CONSUME(tokens.Memory);
+                            this.CONSUME(tokens.Colon);
+                            this.CONSUME(tokens.SizeLiteral);
+                        },
+                    },
+                    {
+                        ALT: () => {
+                            this.CONSUME(tokens.Iterations);
+                            this.CONSUME2(tokens.Colon);
+                            this.CONSUME(tokens.IntegerLiteral);
+                        },
+                    },
+                    {
+                        ALT: () => {
+                            this.CONSUME(tokens.Parallelism);
+                            this.CONSUME3(tokens.Colon);
+                            this.CONSUME2(tokens.IntegerLiteral);
+                        },
+                    },
+                ]);
+            },
+        });
+    });
+    // ---------------------------------------------------------------------------
+    // Entity Block
+    // ---------------------------------------------------------------------------
+    entityBlock = this.RULE('entityBlock', () => {
+        this.CONSUME(tokens.Entity);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => this.SUBRULE(this.entityField) },
+                { ALT: () => this.SUBRULE(this.entityRelationship) },
+                { ALT: () => this.SUBRULE(this.entityCapability) },
+                { ALT: () => this.SUBRULE(this.entityLifecycleHook) },
+            ]);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    // Field name can be an identifier OR a keyword that happens to match a type name
+    // (e.g., "email: email" where first email is field name, second is type)
+    // Also used for color names like "primary", "background"
+    fieldName = this.RULE('fieldName', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Identifier) },
+            // Keywords that could also be field names or color names
+            { ALT: () => this.CONSUME(tokens.Email) },
+            { ALT: () => this.CONSUME(tokens.Password) },
+            { ALT: () => this.CONSUME(tokens.String) },
+            { ALT: () => this.CONSUME(tokens.Int) },
+            { ALT: () => this.CONSUME(tokens.Float) },
+            { ALT: () => this.CONSUME(tokens.Bool) },
+            { ALT: () => this.CONSUME(tokens.Url) },
+            { ALT: () => this.CONSUME(tokens.Uuid) },
+            { ALT: () => this.CONSUME(tokens.Phone) },
+            { ALT: () => this.CONSUME(tokens.Slug) },
+            { ALT: () => this.CONSUME(tokens.Markdown) },
+            { ALT: () => this.CONSUME(tokens.Json) },
+            { ALT: () => this.CONSUME(tokens.Timestamp) },
+            { ALT: () => this.CONSUME(tokens.Date) },
+            { ALT: () => this.CONSUME(tokens.Time) },
+            { ALT: () => this.CONSUME(tokens.Text) },
+            { ALT: () => this.CONSUME(tokens.Primary) },
+            // Additional keywords commonly used as field names
+            { ALT: () => this.CONSUME(tokens.Title) },
+            { ALT: () => this.CONSUME(tokens.Label) },
+            { ALT: () => this.CONSUME(tokens.State) },
+            { ALT: () => this.CONSUME(tokens.Version) },
+            { ALT: () => this.CONSUME(tokens.Color) },
+        ]);
+    });
+    entityField = this.RULE('entityField', () => {
+        this.SUBRULE(this.fieldName);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.fieldType);
+        this.MANY(() => {
+            this.CONSUME(tokens.Comma);
+            this.SUBRULE(this.fieldModifier);
+        });
+        this.OPTION(() => {
+            this.CONSUME(tokens.Equals);
+            this.SUBRULE(this.defaultValue);
+        });
+    });
+    fieldType = this.RULE('fieldType', () => {
+        this.OR([
+            // Array type: [Type]
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.LBracket);
+                    this.SUBRULE(this.innerFieldType);
+                    this.CONSUME(tokens.RBracket);
+                },
+            },
+            // String with optional length constraint (handles both "string" and "string(1..100)")
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.String);
+                    this.OPTION(() => {
+                        this.CONSUME(tokens.LParen);
+                        this.SUBRULE(this.rangeConstraint);
+                        this.CONSUME(tokens.RParen);
+                    });
+                },
+            },
+            // Other primitive types
+            { ALT: () => this.CONSUME(tokens.Int) },
+            { ALT: () => this.CONSUME(tokens.Float) },
+            { ALT: () => this.CONSUME(tokens.Bool) },
+            { ALT: () => this.CONSUME(tokens.Email) },
+            { ALT: () => this.CONSUME(tokens.Url) },
+            { ALT: () => this.CONSUME(tokens.Uuid) },
+            { ALT: () => this.CONSUME(tokens.Phone) },
+            { ALT: () => this.CONSUME(tokens.Slug) },
+            { ALT: () => this.CONSUME(tokens.Markdown) },
+            { ALT: () => this.CONSUME(tokens.Json) },
+            { ALT: () => this.CONSUME(tokens.Timestamp) },
+            { ALT: () => this.CONSUME(tokens.Date) },
+            { ALT: () => this.CONSUME(tokens.Time) },
+            // Enum type (inline)
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Identifier);
+                    this.AT_LEAST_ONE(() => {
+                        this.CONSUME(tokens.Pipe);
+                        this.CONSUME2(tokens.Identifier);
+                    });
+                },
+            },
+            // Reference type
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+        ]);
+    });
+    // Inner field type for arrays (all types except array to avoid recursion issues)
+    innerFieldType = this.RULE('innerFieldType', () => {
+        this.OR([
+            // String with optional length constraint
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.String);
+                    this.OPTION(() => {
+                        this.CONSUME(tokens.LParen);
+                        this.SUBRULE(this.rangeConstraint);
+                        this.CONSUME(tokens.RParen);
+                    });
+                },
+            },
+            // Other primitive types
+            { ALT: () => this.CONSUME(tokens.Int) },
+            { ALT: () => this.CONSUME(tokens.Float) },
+            { ALT: () => this.CONSUME(tokens.Bool) },
+            { ALT: () => this.CONSUME(tokens.Email) },
+            { ALT: () => this.CONSUME(tokens.Url) },
+            { ALT: () => this.CONSUME(tokens.Uuid) },
+            { ALT: () => this.CONSUME(tokens.Phone) },
+            { ALT: () => this.CONSUME(tokens.Slug) },
+            { ALT: () => this.CONSUME(tokens.Markdown) },
+            { ALT: () => this.CONSUME(tokens.Json) },
+            { ALT: () => this.CONSUME(tokens.Timestamp) },
+            { ALT: () => this.CONSUME(tokens.Date) },
+            { ALT: () => this.CONSUME(tokens.Time) },
+            // Enum type (inline)
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Identifier);
+                    this.AT_LEAST_ONE(() => {
+                        this.CONSUME(tokens.Pipe);
+                        this.CONSUME2(tokens.Identifier);
+                    });
+                },
+            },
+            // Reference type
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+        ]);
+    });
+    rangeConstraint = this.RULE('rangeConstraint', () => {
+        this.OPTION(() => this.CONSUME(tokens.IntegerLiteral));
+        this.CONSUME(tokens.DotDot);
+        this.OPTION2(() => this.CONSUME2(tokens.IntegerLiteral));
+    });
+    fieldModifier = this.RULE('fieldModifier', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Primary) },
+            { ALT: () => this.CONSUME(tokens.Unique) },
+            { ALT: () => this.CONSUME(tokens.Auto) },
+            { ALT: () => this.CONSUME(tokens.Immutable) },
+            { ALT: () => this.CONSUME(tokens.Internal) },
+            { ALT: () => this.CONSUME(tokens.Hashed) },
+            { ALT: () => this.CONSUME(tokens.Optional) },
+        ]);
+    });
+    defaultValue = this.RULE('defaultValue', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.StringLiteral) },
+            { ALT: () => this.CONSUME(tokens.IntegerLiteral) },
+            { ALT: () => this.CONSUME(tokens.Identifier) },
+            { ALT: () => this.CONSUME(tokens.True) },
+            { ALT: () => this.CONSUME(tokens.False) },
+        ]);
+    });
+    entityRelationship = this.RULE('entityRelationship', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.HasMany) },
+            { ALT: () => this.CONSUME(tokens.HasOne) },
+            { ALT: () => this.CONSUME(tokens.BelongsTo) },
+            { ALT: () => this.CONSUME(tokens.ManyToMany) },
+        ]);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.PascalIdentifier);
+        // Optional "through JoinEntity" for many-to-many
+        this.OPTION(() => {
+            this.CONSUME(tokens.Through);
+            this.CONSUME2(tokens.PascalIdentifier);
+        });
+        // Optional "(as aliasName)" for relationship alias
+        this.OPTION2(() => {
+            this.CONSUME(tokens.LParen);
+            this.CONSUME(tokens.As);
+            this.CONSUME(tokens.Identifier);
+            this.CONSUME(tokens.RParen);
+        });
+    });
+    entityCapability = this.RULE('entityCapability', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Can) },
+            { ALT: () => this.CONSUME(tokens.Cannot) },
+        ]);
+        this.CONSUME(tokens.Colon);
+        this.OR2([
+            { ALT: () => this.SUBRULE(this.capabilityList) },
+            { ALT: () => this.SUBRULE(this.singleCapability) },
+        ]);
+    });
+    capabilityList = this.RULE('capabilityList', () => {
+        this.CONSUME(tokens.LBracket);
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => this.SUBRULE(this.singleCapability),
+        });
+        this.CONSUME(tokens.RBracket);
+    });
+    singleCapability = this.RULE('singleCapability', () => {
+        this.SUBRULE(this.capabilityAction);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.OPTION(() => {
+            this.CONSUME(tokens.LParen);
+            this.SUBRULE(this.capabilityCondition);
+            this.CONSUME(tokens.RParen);
+        });
+    });
+    capabilityAction = this.RULE('capabilityAction', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Create) },
+            { ALT: () => this.CONSUME(tokens.Read) },
+            { ALT: () => this.CONSUME(tokens.Update) },
+            { ALT: () => this.CONSUME(tokens.Delete) },
+        ]);
+    });
+    capabilityCondition = this.RULE('capabilityCondition', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Where);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Unless);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME2(tokens.Identifier);
+                },
+            },
+        ]);
+    });
+    entityLifecycleHook = this.RULE('entityLifecycleHook', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.OnCreate) },
+            { ALT: () => this.CONSUME(tokens.OnUpdate) },
+            { ALT: () => this.CONSUME(tokens.OnDelete) },
+        ]);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.hookAction);
+    });
+    hookAction = this.RULE('hookAction', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.SendEmail) },
+            { ALT: () => this.CONSUME(tokens.Anonymize) },
+            { ALT: () => this.CONSUME(tokens.Notify) },
+            { ALT: () => this.CONSUME(tokens.Webhook) },
+            { ALT: () => this.CONSUME(tokens.Identifier) },
+        ]);
+        this.CONSUME(tokens.LParen);
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => this.SUBRULE(this.hookActionParam),
+        });
+        this.CONSUME(tokens.RParen);
+    });
+    hookActionParam = this.RULE('hookActionParam', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.StringLiteral) },
+            { ALT: () => this.CONSUME2(tokens.Identifier) },
+            { ALT: () => this.SUBRULE(this.arrayLiteral) },
+        ]);
+    });
+    arrayLiteral = this.RULE('arrayLiteral', () => {
+        this.CONSUME(tokens.LBracket);
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => this.CONSUME(tokens.Identifier),
+        });
+        this.CONSUME(tokens.RBracket);
+    });
+    // ---------------------------------------------------------------------------
+    // API Block
+    // ---------------------------------------------------------------------------
+    apiBlock = this.RULE('apiBlock', () => {
+        this.CONSUME(tokens.Api);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.OR([
+                { ALT: () => this.SUBRULE(this.crudShorthand) },
+                { ALT: () => this.SUBRULE(this.apiEndpoint) },
+            ]);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    // CRUD shorthand: crud: User [create, read, update, delete] -[DB, Auth]->
+    crudShorthand = this.RULE('crudShorthand', () => {
+        this.CONSUME(tokens.Crud);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.PascalIdentifier); // Entity name
+        this.CONSUME(tokens.LBracket);
+        this.SUBRULE(this.crudActionList);
+        this.CONSUME(tokens.RBracket);
+        this.OPTION(() => this.SUBRULE(this.effectAnnotation));
+    });
+    crudActionList = this.RULE('crudActionList', () => {
+        this.SUBRULE(this.crudAction);
+        this.MANY(() => {
+            this.CONSUME(tokens.Comma);
+            this.SUBRULE2(this.crudAction);
+        });
+    });
+    crudAction = this.RULE('crudAction', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Create) },
+            { ALT: () => this.CONSUME(tokens.Read) },
+            { ALT: () => this.CONSUME(tokens.Update) },
+            { ALT: () => this.CONSUME(tokens.Delete) },
+            { ALT: () => this.CONSUME(tokens.List) },
+        ]);
+    });
+    apiEndpoint = this.RULE('apiEndpoint', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.LParen);
+        this.OPTION(() => this.SUBRULE(this.parameterList));
+        this.CONSUME(tokens.RParen);
+        this.SUBRULE(this.effectAnnotation);
+        this.SUBRULE(this.returnType);
+    });
+    parameterList = this.RULE('parameterList', () => {
+        this.SUBRULE(this.parameter);
+        this.MANY(() => {
+            this.CONSUME(tokens.Comma);
+            this.SUBRULE2(this.parameter);
+        });
+    });
+    parameter = this.RULE('parameter', () => {
+        // Parameter name can be identifier or keyword (e.g., "email: email")
+        this.SUBRULE(this.fieldName);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.parameterType);
+    });
+    parameterType = this.RULE('parameterType', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.String) },
+            { ALT: () => this.CONSUME(tokens.Int) },
+            { ALT: () => this.CONSUME(tokens.Float) },
+            { ALT: () => this.CONSUME(tokens.Bool) },
+            { ALT: () => this.CONSUME(tokens.Email) },
+            { ALT: () => this.CONSUME(tokens.Uuid) },
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+        ]);
+    });
+    effectAnnotation = this.RULE('effectAnnotation', () => {
+        this.CONSUME(tokens.EffectArrowStart);
+        this.SUBRULE(this.effectList);
+        this.CONSUME(tokens.EffectArrowEnd);
+    });
+    effectList = this.RULE('effectList', () => {
+        this.SUBRULE(this.effect);
+        this.MANY(() => {
+            this.CONSUME(tokens.Comma);
+            this.SUBRULE2(this.effect);
+        });
+    });
+    effect = this.RULE('effect', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.DB) },
+            { ALT: () => this.CONSUME(tokens.AuthEffect) },
+            { ALT: () => this.CONSUME(tokens.EmailEffect) },
+            { ALT: () => this.CONSUME(tokens.ErrorEffect) },
+            { ALT: () => this.CONSUME(tokens.Cache) },
+            { ALT: () => this.CONSUME(tokens.Queue) },
+            { ALT: () => this.CONSUME(tokens.External) },
+            { ALT: () => this.CONSUME(tokens.Identifier) },
+        ]);
+    });
+    returnType = this.RULE('returnType', () => {
+        this.OR([
+            // Void
+            { ALT: () => this.CONSUME(tokens.Void) },
+            // Array type
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.LBracket);
+                    this.SUBRULE(this.returnTypeInner);
+                    this.CONSUME(tokens.RBracket);
+                },
+            },
+            // Object type
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.LBrace);
+                    this.SUBRULE(this.objectTypeFields);
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+            // Simple type
+            { ALT: () => this.SUBRULE2(this.returnTypeInner) },
+        ]);
+    });
+    returnTypeInner = this.RULE('returnTypeInner', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.PascalIdentifier) },
+            { ALT: () => this.CONSUME(tokens.String) },
+            { ALT: () => this.CONSUME(tokens.Int) },
+            { ALT: () => this.CONSUME(tokens.Bool) },
+        ]);
+        // Optional join with another type
+        this.OPTION(() => {
+            this.CONSUME(tokens.Ampersand);
+            this.CONSUME(tokens.LBrace);
+            this.SUBRULE(this.objectTypeFields);
+            this.CONSUME(tokens.RBrace);
+        });
+    });
+    objectTypeFields = this.RULE('objectTypeFields', () => {
+        this.SUBRULE(this.objectTypeField);
+        this.MANY(() => {
+            this.CONSUME(tokens.Comma);
+            this.SUBRULE2(this.objectTypeField);
+        });
+    });
+    objectTypeField = this.RULE('objectTypeField', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.returnTypeInner);
+    });
+    // ---------------------------------------------------------------------------
+    // Journey Block
+    // ---------------------------------------------------------------------------
+    journeyBlock = this.RULE('journeyBlock', () => {
+        this.CONSUME(tokens.Journey);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.journeyProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    journeyProperty = this.RULE('journeyProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Actor);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Steps);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.journeyStep);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    journeyStep = this.RULE('journeyStep', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY_SEP({
+            SEP: tokens.Comma,
+            DEF: () => this.SUBRULE(this.journeyStepProperty),
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    journeyStepProperty = this.RULE('journeyStepProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Page);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.PascalIdentifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Next);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.WaitFor);
+                    this.CONSUME3(tokens.Colon);
+                    this.CONSUME2(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Action);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME3(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Condition);
+                    this.CONSUME5(tokens.Colon);
+                    this.CONSUME4(tokens.Identifier);
+                },
+            },
+        ]);
+    });
+    // ---------------------------------------------------------------------------
+    // Page Block
+    // ---------------------------------------------------------------------------
+    pageBlock = this.RULE('pageBlock', () => {
+        this.CONSUME(tokens.Page);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.pageProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    pageProperty = this.RULE('pageProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Route);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Layout);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME(tokens.PascalIdentifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Loader);
+                    this.CONSUME3(tokens.Colon);
+                    this.CONSUME(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Guard);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME2(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Meta);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.metaProperty);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    metaProperty = this.RULE('metaProperty', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.StringLiteral);
+    });
+    // ---------------------------------------------------------------------------
+    // Component Block
+    // ---------------------------------------------------------------------------
+    componentBlock = this.RULE('componentBlock', () => {
+        this.CONSUME(tokens.Component);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.componentProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    componentProperty = this.RULE('componentProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Props);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.propDefinition);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.State);
+                    this.CONSUME2(tokens.LBrace);
+                    this.MANY2(() => {
+                        this.SUBRULE(this.stateDefinition);
+                    });
+                    this.CONSUME2(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Handlers);
+                    this.CONSUME3(tokens.LBrace);
+                    this.MANY3(() => {
+                        this.SUBRULE(this.handlerDefinition);
+                    });
+                    this.CONSUME3(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    propDefinition = this.RULE('propDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.parameterType);
+        this.OPTION(() => {
+            this.CONSUME(tokens.Question);
+        });
+    });
+    stateDefinition = this.RULE('stateDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.parameterType);
+        this.OPTION(() => {
+            this.CONSUME(tokens.Equals);
+            this.SUBRULE(this.defaultValue);
+        });
+    });
+    handlerDefinition = this.RULE('handlerDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.effectAnnotation);
+        this.CONSUME(tokens.Void);
+    });
+    // ---------------------------------------------------------------------------
+    // Form Block
+    // ---------------------------------------------------------------------------
+    formBlock = this.RULE('formBlock', () => {
+        this.CONSUME(tokens.Form);
+        this.CONSUME(tokens.PascalIdentifier);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.formProperty);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    formProperty = this.RULE('formProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Fields);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.formFieldDefinition);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Submit);
+                    this.CONSUME2(tokens.LBrace);
+                    this.MANY2(() => {
+                        this.SUBRULE(this.submitProperty);
+                    });
+                    this.CONSUME2(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Validation);
+                    this.CONSUME3(tokens.LBrace);
+                    this.MANY3(() => {
+                        this.SUBRULE(this.validationRule);
+                    });
+                    this.CONSUME3(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    formFieldDefinition = this.RULE('formFieldDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.SUBRULE(this.formFieldType);
+        this.OPTION(() => {
+            this.CONSUME(tokens.LBrace);
+            this.MANY(() => {
+                this.SUBRULE(this.formFieldProperty);
+            });
+            this.CONSUME(tokens.RBrace);
+        });
+    });
+    formFieldType = this.RULE('formFieldType', () => {
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.Text) },
+            { ALT: () => this.CONSUME(tokens.Textarea) },
+            { ALT: () => this.CONSUME(tokens.Email) },
+            { ALT: () => this.CONSUME(tokens.Password) },
+            { ALT: () => this.CONSUME(tokens.Number) },
+            { ALT: () => this.CONSUME(tokens.Checkbox) },
+            { ALT: () => this.CONSUME(tokens.Radio) },
+            { ALT: () => this.CONSUME(tokens.Select) },
+            { ALT: () => this.CONSUME(tokens.Date) },
+            { ALT: () => this.CONSUME(tokens.File) },
+        ]);
+    });
+    formFieldProperty = this.RULE('formFieldProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Label);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Placeholder);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME2(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Required);
+                    this.CONSUME3(tokens.Colon);
+                    this.OR2([
+                        { ALT: () => this.CONSUME(tokens.True) },
+                        { ALT: () => this.CONSUME(tokens.False) },
+                    ]);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Rows);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME(tokens.IntegerLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Options);
+                    this.CONSUME(tokens.LBracket);
+                    this.MANY_SEP({
+                        SEP: tokens.Comma,
+                        DEF: () => this.CONSUME3(tokens.StringLiteral),
+                    });
+                    this.CONSUME(tokens.RBracket);
+                },
+            },
+        ]);
+    });
+    submitProperty = this.RULE('submitProperty', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Action);
+                    this.CONSUME(tokens.Colon);
+                    this.CONSUME(tokens.Identifier);
+                    this.CONSUME(tokens.Dot);
+                    this.CONSUME2(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Button);
+                    this.CONSUME2(tokens.Colon);
+                    this.CONSUME(tokens.StringLiteral);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.OnSuccess);
+                    this.CONSUME3(tokens.Colon);
+                    this.CONSUME3(tokens.Identifier);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.OnError);
+                    this.CONSUME4(tokens.Colon);
+                    this.CONSUME4(tokens.Identifier);
+                },
+            },
+        ]);
+    });
+    validationRule = this.RULE('validationRule', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME2(tokens.Identifier);
+    });
+    // ---------------------------------------------------------------------------
+    // Design Block
+    // ---------------------------------------------------------------------------
+    designBlock = this.RULE('designBlock', () => {
+        this.CONSUME(tokens.Design);
+        this.CONSUME(tokens.LBrace);
+        this.MANY(() => {
+            this.SUBRULE(this.designSection);
+        });
+        this.CONSUME(tokens.RBrace);
+    });
+    designSection = this.RULE('designSection', () => {
+        this.OR([
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Colors);
+                    this.CONSUME(tokens.LBrace);
+                    this.MANY(() => {
+                        this.SUBRULE(this.colorDefinition);
+                    });
+                    this.CONSUME(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Typography);
+                    this.CONSUME2(tokens.LBrace);
+                    this.MANY2(() => {
+                        this.SUBRULE(this.typographyDefinition);
+                    });
+                    this.CONSUME2(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Spacing);
+                    this.CONSUME3(tokens.LBrace);
+                    this.MANY3(() => {
+                        this.SUBRULE(this.spacingDefinition);
+                    });
+                    this.CONSUME3(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Animation);
+                    this.CONSUME4(tokens.LBrace);
+                    this.MANY4(() => {
+                        this.SUBRULE(this.animationDefinition);
+                    });
+                    this.CONSUME4(tokens.RBrace);
+                },
+            },
+            {
+                ALT: () => {
+                    this.CONSUME(tokens.Dark);
+                    this.CONSUME5(tokens.LBrace);
+                    this.MANY5(() => {
+                        this.SUBRULE2(this.colorDefinition);
+                    });
+                    this.CONSUME5(tokens.RBrace);
+                },
+            },
+        ]);
+    });
+    colorDefinition = this.RULE('colorDefinition', () => {
+        this.SUBRULE(this.fieldName);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.HexColor);
+    });
+    typographyDefinition = this.RULE('typographyDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.StringLiteral) },
+            { ALT: () => this.CONSUME(tokens.SizeLiteral) },
+            { ALT: () => this.CONSUME(tokens.IntegerLiteral) },
+        ]);
+    });
+    spacingDefinition = this.RULE('spacingDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.CONSUME(tokens.SizeLiteral);
+    });
+    animationDefinition = this.RULE('animationDefinition', () => {
+        this.CONSUME(tokens.Identifier);
+        this.CONSUME(tokens.Colon);
+        this.OR([
+            { ALT: () => this.CONSUME(tokens.DurationLiteral) },
+            { ALT: () => this.CONSUME(tokens.CSSFunctionLiteral) },
+            { ALT: () => this.CONSUME(tokens.StringLiteral) },
+        ]);
+    });
+}
+// =============================================================================
+// Parser Instance
+// =============================================================================
+const parser = new KappaParser();
+// =============================================================================
+// CST Visitor for AST Construction
+// =============================================================================
+const BaseCstVisitor = parser.getBaseCstVisitorConstructor();
+class KappaAstBuilder extends BaseCstVisitor {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    // Helper: Extract source location from tokens
+    getLocation(ctx) {
+        const firstToken = this.findFirstToken(ctx);
+        const lastToken = this.findLastToken(ctx);
+        if (!firstToken || !lastToken) {
+            return {
+                startLine: 0,
+                startColumn: 0,
+                endLine: 0,
+                endColumn: 0,
+                startOffset: 0,
+                endOffset: 0,
+            };
+        }
+        return {
+            startLine: firstToken.startLine ?? 0,
+            startColumn: firstToken.startColumn ?? 0,
+            endLine: lastToken.endLine ?? 0,
+            endColumn: lastToken.endColumn ?? 0,
+            startOffset: firstToken.startOffset,
+            endOffset: lastToken.endOffset ?? firstToken.startOffset,
+        };
+    }
+    findFirstToken(ctx) {
+        let first = null;
+        for (const key of Object.keys(ctx)) {
+            const val = ctx[key];
+            if (Array.isArray(val) && val.length > 0) {
+                const token = val[0];
+                if (token && typeof token === 'object' && 'startOffset' in token) {
+                    if (!first || token.startOffset < first.startOffset) {
+                        first = token;
+                    }
+                }
+            }
+        }
+        return first;
+    }
+    findLastToken(ctx) {
+        let last = null;
+        for (const key of Object.keys(ctx)) {
+            const val = ctx[key];
+            if (Array.isArray(val) && val.length > 0) {
+                const token = val[val.length - 1];
+                if (token && typeof token === 'object' && 'endOffset' in token) {
+                    const endOffset = token.endOffset ?? token.startOffset;
+                    if (!last || endOffset > (last.endOffset ?? last.startOffset)) {
+                        last = token;
+                    }
+                }
+            }
+        }
+        return last;
+    }
+    // Root visitor
+    kappaSpec(ctx) {
+        const project = ctx.projectBlock ? this.visit(ctx.projectBlock) : undefined;
+        const auth = ctx.authBlock ? this.visit(ctx.authBlock) : undefined;
+        const entities = ctx.entityBlock
+            ? ctx.entityBlock.map((e) => this.visit(e))
+            : [];
+        const apis = ctx.apiBlock ? ctx.apiBlock.map((a) => this.visit(a)) : [];
+        const journeys = ctx.journeyBlock
+            ? ctx.journeyBlock.map((j) => this.visit(j))
+            : [];
+        const pages = ctx.pageBlock ? ctx.pageBlock.map((p) => this.visit(p)) : [];
+        const components = ctx.componentBlock
+            ? ctx.componentBlock.map((c) => this.visit(c))
+            : [];
+        const forms = ctx.formBlock ? ctx.formBlock.map((f) => this.visit(f)) : [];
+        const design = ctx.designBlock ? this.visit(ctx.designBlock) : undefined;
+        return {
+            kind: 'KappaSpec',
+            loc: this.getLocation(ctx),
+            project,
+            auth,
+            entities,
+            apis,
+            journeys,
+            pages,
+            components,
+            forms,
+            design,
+        };
+    }
+    // Project block visitor
+    projectBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const properties = ctx.projectProperty
+            ? ctx.projectProperty.map((p) => this.visit(p))
+            : [];
+        const block = {
+            kind: 'ProjectBlock',
+            loc: this.getLocation(ctx),
+            name,
+            stack: 'tanstack-start', // Default
+        };
+        for (const prop of properties) {
+            if (prop.type === 'version')
+                block.version = prop.value;
+            if (prop.type === 'stack')
+                block.stack = prop.value;
+            if (prop.type === 'database')
+                block.database = prop.value;
+            if (prop.type === 'auth')
+                block.auth = prop.value;
+            if (prop.type === 'ui')
+                block.ui = prop.value;
+        }
+        return block;
+    }
+    projectProperty(ctx) {
+        if (ctx.Version) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'version', value: value.slice(1, -1) }; // Remove quotes
+        }
+        if (ctx.Stack) {
+            return { type: 'stack', value: this.visit(ctx.stackValue) };
+        }
+        if (ctx.Database) {
+            return { type: 'database', value: this.visit(ctx.databaseValue) };
+        }
+        if (ctx.Auth) {
+            return { type: 'auth', value: this.visit(ctx.authTypeValue) };
+        }
+        if (ctx.Ui) {
+            return { type: 'ui', value: this.visit(ctx.uiValue) };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    stackValue(ctx) {
+        if (ctx.TanstackStart)
+            return 'tanstack-start';
+        if (ctx.Nextjs)
+            return 'next';
+        if (ctx.Remix)
+            return 'remix';
+        if (ctx.Sveltekit)
+            return 'sveltekit';
+        if (ctx.Astro)
+            return 'astro';
+        if (ctx.Express)
+            return 'express';
+        if (ctx.Hono)
+            return 'hono';
+        if (ctx.Elysia)
+            return 'elysia';
+        return 'tanstack-start';
+    }
+    databaseValue(ctx) {
+        if (ctx.Postgres)
+            return 'postgres';
+        if (ctx.Mysql)
+            return 'mysql';
+        if (ctx.Sqlite)
+            return 'sqlite';
+        if (ctx.Turso)
+            return 'turso';
+        if (ctx.Mongodb)
+            return 'mongodb';
+        return 'postgres';
+    }
+    authTypeValue(ctx) {
+        if (ctx.Jwt)
+            return 'jwt';
+        if (ctx.Session)
+            return 'session';
+        if (ctx.Oauth)
+            return 'oauth';
+        return 'jwt';
+    }
+    uiValue(ctx) {
+        if (ctx.Shadcn)
+            return 'shadcn';
+        if (ctx.Mui)
+            return 'mui';
+        if (ctx.Chakra)
+            return 'chakra';
+        if (ctx.TailwindOnly)
+            return 'tailwind-only';
+        return 'shadcn';
+    }
+    // Auth block visitor
+    authBlock(ctx) {
+        const type = ctx.Jwt ? 'jwt' : 'session';
+        const properties = ctx.authProperty
+            ? ctx.authProperty.map((p) => this.visit(p))
+            : [];
+        const block = {
+            kind: 'AuthBlock',
+            loc: this.getLocation(ctx),
+            type,
+        };
+        if (type === 'jwt') {
+            const jwt = {
+                kind: 'JWTConfig',
+                loc: this.getLocation(ctx),
+                secret: '',
+                expires: '7d',
+                hash: { kind: 'HashConfig', loc: this.getLocation(ctx), algorithm: 'argon2id' },
+            };
+            for (const prop of properties) {
+                if (prop.type === 'secret')
+                    jwt.secret = prop.value;
+                if (prop.type === 'issuer')
+                    jwt.issuer = prop.value;
+                if (prop.type === 'audience')
+                    jwt.audience = prop.value;
+                if (prop.type === 'expires')
+                    jwt.expires = prop.value;
+                if (prop.type === 'refresh')
+                    jwt.refresh = prop.value;
+                if (prop.type === 'hash')
+                    jwt.hash = prop.value;
+            }
+            block.jwt = jwt;
+        }
+        else {
+            const session = {
+                kind: 'SessionConfig',
+                loc: this.getLocation(ctx),
+                duration: '24h',
+                hash: { kind: 'HashConfig', loc: this.getLocation(ctx), algorithm: 'argon2id' },
+            };
+            for (const prop of properties) {
+                if (prop.type === 'duration')
+                    session.duration = prop.value;
+                if (prop.type === 'hash')
+                    session.hash = prop.value;
+            }
+            block.session = session;
+        }
+        return block;
+    }
+    authProperty(ctx) {
+        if (ctx.Secret) {
+            return { type: 'secret', value: this.visit(ctx.envCall) };
+        }
+        if (ctx.Issuer) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'issuer', value: value.slice(1, -1) };
+        }
+        if (ctx.Audience) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'audience', value: value.slice(1, -1) };
+        }
+        if (ctx.Expires) {
+            return { type: 'expires', value: (ctx.DurationLiteral?.[0])?.image ?? '7d' };
+        }
+        if (ctx.Refresh) {
+            return { type: 'refresh', value: this.visit(ctx.refreshValue) };
+        }
+        if (ctx.Hash) {
+            return { type: 'hash', value: this.visit(ctx.hashConfig) };
+        }
+        if (ctx.Duration) {
+            return { type: 'duration', value: (ctx.DurationLiteral?.[0])?.image ?? '24h' };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    envCall(ctx) {
+        return ctx.ConstantIdentifier?.[0]?.image ?? ctx.PascalIdentifier?.[0]?.image ?? ctx.Identifier?.[0]?.image ?? '';
+    }
+    refreshValue(ctx) {
+        if (ctx.Sliding)
+            return 'sliding';
+        if (ctx.Fixed)
+            return 'fixed';
+        if (ctx.None)
+            return 'none';
+        return 'sliding';
+    }
+    hashConfig(ctx) {
+        const algorithm = ctx.Argon2id ? 'argon2id' : 'bcrypt';
+        const config = {
+            kind: 'HashConfig',
+            loc: this.getLocation(ctx),
+            algorithm,
+        };
+        if (ctx.hashParams) {
+            const params = this.visit(ctx.hashParams);
+            Object.assign(config, params);
+        }
+        if (ctx.IntegerLiteral && algorithm === 'bcrypt') {
+            config.rounds = parseInt((ctx.IntegerLiteral?.[0])?.image ?? '10', 10);
+        }
+        return config;
+    }
+    hashParams(ctx) {
+        const params = {};
+        if (ctx.Memory) {
+            params.memory = (ctx.SizeLiteral?.[0])?.image;
+        }
+        if (ctx.Iterations) {
+            params.iterations = parseInt((ctx.IntegerLiteral?.[0])?.image ?? '3', 10);
+        }
+        if (ctx.Parallelism) {
+            params.parallelism = parseInt((ctx.IntegerLiteral?.[1] ?? ctx.IntegerLiteral?.[0])?.image ?? '1', 10);
+        }
+        return params;
+    }
+    // Entity block visitor (placeholder - will be extended)
+    entityBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const fields = ctx.entityField
+            ? ctx.entityField.map((f) => this.visit(f))
+            : [];
+        const relationships = ctx.entityRelationship
+            ? ctx.entityRelationship.map((r) => this.visit(r))
+            : [];
+        const capabilities = ctx.entityCapability
+            ? ctx.entityCapability.map((c) => this.visit(c))
+            : [];
+        const lifecycleHooks = ctx.entityLifecycleHook
+            ? ctx.entityLifecycleHook.map((h) => this.visit(h))
+            : [];
+        return {
+            kind: 'EntityBlock',
+            loc: this.getLocation(ctx),
+            name,
+            fields,
+            relationships,
+            capabilities,
+            lifecycleHooks,
+            indexes: [],
+        };
+    }
+    entityField(ctx) {
+        const name = ctx.fieldName ? this.visit(ctx.fieldName) : '';
+        const type = this.visit(ctx.fieldType);
+        const modifiers = ctx.fieldModifier
+            ? ctx.fieldModifier.map((m) => this.visit(m))
+            : [];
+        const defaultValue = ctx.defaultValue ? this.visit(ctx.defaultValue) : undefined;
+        return {
+            kind: 'EntityField',
+            loc: this.getLocation(ctx),
+            name,
+            type,
+            modifiers,
+            defaultValue,
+        };
+    }
+    fieldName(ctx) {
+        // Extract the image from whichever token was matched
+        const tokenTypes = [
+            'Identifier',
+            'Email',
+            'Password',
+            'String',
+            'Int',
+            'Float',
+            'Bool',
+            'Url',
+            'Uuid',
+            'Phone',
+            'Slug',
+            'Markdown',
+            'Json',
+            'Timestamp',
+            'Date',
+            'Time',
+            'Text',
+            'Primary',
+        ];
+        for (const tokenType of tokenTypes) {
+            const token = ctx[tokenType]?.[0];
+            if (token) {
+                return token.image;
+            }
+        }
+        return '';
+    }
+    fieldType(ctx) {
+        // Check for array type first
+        if (ctx.innerFieldType) {
+            const itemType = this.visit(ctx.innerFieldType);
+            return {
+                kind: 'array',
+                itemType,
+            };
+        }
+        // Check for enum type (multiple identifiers with pipes)
+        if (ctx.Pipe) {
+            const identifiers = ctx.Identifier;
+            return {
+                kind: 'enum',
+                values: identifiers.map((t) => t.image),
+            };
+        }
+        // Check for string with range constraint
+        if (ctx.rangeConstraint) {
+            const range = this.visit(ctx.rangeConstraint);
+            return {
+                kind: 'primitive',
+                type: 'string',
+                range,
+            };
+        }
+        // Check for reference type
+        if (ctx.PascalIdentifier) {
+            return {
+                kind: 'reference',
+                entity: (ctx.PascalIdentifier?.[0])?.image ?? '',
+                optional: false,
+            };
+        }
+        // Primitive types
+        const primitiveMap = {
+            String: 'string',
+            Int: 'int',
+            Float: 'float',
+            Bool: 'bool',
+            Email: 'email',
+            Url: 'url',
+            Uuid: 'uuid',
+            Phone: 'phone',
+            Slug: 'slug',
+            Markdown: 'markdown',
+            Json: 'json',
+            Timestamp: 'timestamp',
+            Date: 'date',
+            Time: 'time',
+        };
+        for (const [key, value] of Object.entries(primitiveMap)) {
+            if (ctx[key]) {
+                return { kind: 'primitive', type: value };
+            }
+        }
+        return { kind: 'primitive', type: 'string' };
+    }
+    // Inner field type visitor (for array item types - same logic without array recursion)
+    innerFieldType(ctx) {
+        // Check for enum type (multiple identifiers with pipes)
+        if (ctx.Pipe) {
+            const identifiers = ctx.Identifier;
+            return {
+                kind: 'enum',
+                values: identifiers.map((t) => t.image),
+            };
+        }
+        // Check for string with range constraint
+        if (ctx.rangeConstraint) {
+            const range = this.visit(ctx.rangeConstraint);
+            return {
+                kind: 'primitive',
+                type: 'string',
+                range,
+            };
+        }
+        // Check for reference type
+        if (ctx.PascalIdentifier) {
+            return {
+                kind: 'reference',
+                entity: (ctx.PascalIdentifier?.[0])?.image ?? '',
+                optional: false,
+            };
+        }
+        // Primitive types
+        const primitiveMap = {
+            String: 'string',
+            Int: 'int',
+            Float: 'float',
+            Bool: 'bool',
+            Email: 'email',
+            Url: 'url',
+            Uuid: 'uuid',
+            Phone: 'phone',
+            Slug: 'slug',
+            Markdown: 'markdown',
+            Json: 'json',
+            Timestamp: 'timestamp',
+            Date: 'date',
+            Time: 'time',
+        };
+        for (const [key, value] of Object.entries(primitiveMap)) {
+            if (ctx[key]) {
+                return { kind: 'primitive', type: value };
+            }
+        }
+        return { kind: 'primitive', type: 'string' };
+    }
+    rangeConstraint(ctx) {
+        const integers = ctx.IntegerLiteral ?? [];
+        if (integers.length === 2) {
+            return {
+                min: parseInt(integers[0].image, 10),
+                max: parseInt(integers[1].image, 10),
+            };
+        }
+        if (integers.length === 1) {
+            // Could be min or max depending on position
+            return { max: parseInt(integers[0].image, 10) };
+        }
+        return {};
+    }
+    fieldModifier(ctx) {
+        if (ctx.Primary)
+            return 'primary';
+        if (ctx.Unique)
+            return 'unique';
+        if (ctx.Auto)
+            return 'auto';
+        if (ctx.Immutable)
+            return 'immutable';
+        if (ctx.Internal)
+            return 'internal';
+        if (ctx.Hashed)
+            return 'hashed';
+        if (ctx.Optional)
+            return 'optional';
+        return 'optional';
+    }
+    defaultValue(ctx) {
+        if (ctx.StringLiteral)
+            return ctx.StringLiteral[0].image.slice(1, -1);
+        if (ctx.IntegerLiteral)
+            return ctx.IntegerLiteral[0].image;
+        if (ctx.Identifier)
+            return ctx.Identifier[0].image;
+        if (ctx.True)
+            return 'true';
+        if (ctx.False)
+            return 'false';
+        return '';
+    }
+    entityRelationship(ctx) {
+        let type;
+        if (ctx.HasMany)
+            type = 'has_many';
+        else if (ctx.HasOne)
+            type = 'has_one';
+        else if (ctx.ManyToMany)
+            type = 'many_to_many';
+        else
+            type = 'belongs_to';
+        const pascalIds = ctx.PascalIdentifier;
+        const entity = pascalIds?.[0]?.image ?? '';
+        // Second PascalIdentifier is the "through" entity (only present with ManyToMany)
+        const through = ctx.Through ? pascalIds?.[1]?.image : undefined;
+        const as = ctx.As ? (ctx.Identifier?.[0])?.image : undefined;
+        return {
+            kind: 'EntityRelationship',
+            loc: this.getLocation(ctx),
+            type,
+            entity,
+            as,
+            through,
+        };
+    }
+    entityCapability(ctx) {
+        const allowed = !!ctx.Can;
+        const capData = ctx.singleCapability
+            ? this.visit(ctx.singleCapability)
+            : { action: 'read', entity: '' };
+        return {
+            kind: 'Capability',
+            loc: this.getLocation(ctx),
+            allowed,
+            action: capData.action,
+            target: capData.entity,
+            condition: capData.condition?.type === 'where' ? capData.condition.value : undefined,
+            unless: capData.condition?.type === 'unless' ? capData.condition.value : undefined,
+        };
+    }
+    capabilityList(ctx) {
+        return ctx.singleCapability
+            ? ctx.singleCapability.map((c) => this.visit(c))
+            : [];
+    }
+    singleCapability(ctx) {
+        const action = this.visit(ctx.capabilityAction);
+        const entity = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const condition = ctx.capabilityCondition
+            ? this.visit(ctx.capabilityCondition)
+            : undefined;
+        return { action, entity, condition };
+    }
+    capabilityAction(ctx) {
+        if (ctx.Create)
+            return 'create';
+        if (ctx.Read)
+            return 'read';
+        if (ctx.Update)
+            return 'update';
+        if (ctx.Delete)
+            return 'delete';
+        return 'read';
+    }
+    capabilityCondition(ctx) {
+        if (ctx.Where) {
+            return { type: 'where', value: ctx.Identifier?.[0]?.image ?? '' };
+        }
+        return { type: 'unless', value: ctx.Identifier?.[0]?.image ?? '' };
+    }
+    entityLifecycleHook(ctx) {
+        let event;
+        if (ctx.OnCreate)
+            event = 'on_create';
+        else if (ctx.OnUpdate)
+            event = 'on_update';
+        else
+            event = 'on_delete';
+        const actionData = this.visit(ctx.hookAction);
+        return {
+            kind: 'LifecycleHook',
+            loc: this.getLocation(ctx),
+            event,
+            actions: [{
+                    kind: 'LifecycleAction',
+                    loc: this.getLocation(ctx),
+                    type: actionData.name,
+                    params: actionData.params,
+                }],
+        };
+    }
+    hookAction(ctx) {
+        let name;
+        if (ctx.SendEmail)
+            name = 'send_email';
+        else if (ctx.Anonymize)
+            name = 'anonymize';
+        else if (ctx.Notify)
+            name = 'notify';
+        else if (ctx.Webhook)
+            name = 'webhook';
+        else
+            name = (ctx.Identifier?.[0])?.image ?? '';
+        const params = {};
+        if (ctx.hookActionParam) {
+            for (const p of ctx.hookActionParam) {
+                const param = this.visit(p);
+                params[param.name] = param.value;
+            }
+        }
+        return { name, params };
+    }
+    hookActionParam(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        let value;
+        if (ctx.StringLiteral) {
+            value = (ctx.StringLiteral?.[0])?.image.slice(1, -1);
+        }
+        else if (ctx.arrayLiteral) {
+            value = this.visit(ctx.arrayLiteral);
+        }
+        else {
+            value = (ctx.Identifier?.[1])?.image ?? '';
+        }
+        return { name, value };
+    }
+    arrayLiteral(ctx) {
+        return (ctx.Identifier ?? []).map((t) => t.image);
+    }
+    // API block visitor
+    apiBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const operations = ctx.apiEndpoint
+            ? ctx.apiEndpoint.map((e) => this.visit(e))
+            : [];
+        const crud = ctx.crudShorthand
+            ? ctx.crudShorthand.map((c) => this.visit(c))
+            : [];
+        return {
+            kind: 'APIBlock',
+            loc: this.getLocation(ctx),
+            name,
+            operations,
+            crud,
+        };
+    }
+    crudShorthand(ctx) {
+        const entity = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const actionList = ctx.crudActionList
+            ? this.visit(ctx.crudActionList)
+            : [];
+        const effects = ctx.effectAnnotation
+            ? this.visit(ctx.effectAnnotation)
+            : ['DB']; // Default to DB effect
+        const actions = actionList.map((action) => ({
+            action,
+            effects,
+        }));
+        return {
+            kind: 'CRUDShorthand',
+            loc: this.getLocation(ctx),
+            entity,
+            actions,
+        };
+    }
+    crudActionList(ctx) {
+        return ctx.crudAction
+            ? ctx.crudAction.map((a) => this.visit(a))
+            : [];
+    }
+    crudAction(ctx) {
+        if (ctx.Create)
+            return 'create';
+        if (ctx.Read)
+            return 'read';
+        if (ctx.Update)
+            return 'update';
+        if (ctx.Delete)
+            return 'delete';
+        if (ctx.List)
+            return 'list';
+        return 'read';
+    }
+    apiEndpoint(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const parameters = ctx.parameterList ? this.visit(ctx.parameterList) : [];
+        const effects = this.visit(ctx.effectAnnotation);
+        const returnType = this.visit(ctx.returnType);
+        return {
+            kind: 'APIOperation',
+            loc: this.getLocation(ctx),
+            name,
+            parameters,
+            effects,
+            returnType,
+        };
+    }
+    parameterList(ctx) {
+        return ctx.parameter ? ctx.parameter.map((p) => this.visit(p)) : [];
+    }
+    parameter(ctx) {
+        const name = ctx.fieldName ? this.visit(ctx.fieldName) : '';
+        const type = this.visit(ctx.parameterType);
+        return {
+            kind: 'APIParameter',
+            loc: this.getLocation(ctx),
+            name,
+            type,
+            optional: false,
+        };
+    }
+    parameterType(ctx) {
+        if (ctx.String)
+            return 'string';
+        if (ctx.Int)
+            return 'int';
+        if (ctx.Float)
+            return 'float';
+        if (ctx.Bool)
+            return 'bool';
+        if (ctx.Email)
+            return 'email';
+        if (ctx.Uuid)
+            return 'uuid';
+        if (ctx.PascalIdentifier)
+            return ctx.PascalIdentifier[0].image;
+        return 'string';
+    }
+    effectAnnotation(ctx) {
+        return this.visit(ctx.effectList);
+    }
+    effectList(ctx) {
+        return ctx.effect ? ctx.effect.map((e) => this.visit(e)) : [];
+    }
+    effect(ctx) {
+        if (ctx.DB)
+            return 'DB';
+        if (ctx.AuthEffect)
+            return 'Auth';
+        if (ctx.EmailEffect)
+            return 'Email';
+        if (ctx.Audit)
+            return 'Audit';
+        if (ctx.Cache)
+            return 'Cache';
+        if (ctx.Queue)
+            return 'Queue';
+        if (ctx.External)
+            return 'External';
+        return ctx.Identifier?.[0]?.image ?? 'DB';
+    }
+    returnType(ctx) {
+        const loc = this.getLocation(ctx);
+        if (ctx.Void) {
+            return { kind: 'APIReturnType', loc, type: 'void', isArray: false };
+        }
+        if (ctx.objectTypeFields) {
+            const fields = this.visit(ctx.objectTypeFields);
+            const fieldStr = fields.map(f => `${f.name}: ${f.type}`).join(', ');
+            return { kind: 'APIReturnType', loc, type: `{ ${fieldStr} }`, isArray: false };
+        }
+        if (ctx.LBracket) {
+            const inner = this.returnTypeInner(ctx.returnTypeInner);
+            return {
+                kind: 'APIReturnType',
+                loc,
+                type: inner.type,
+                isArray: true,
+                joined: inner.joined
+            };
+        }
+        const inner = this.returnTypeInner(ctx.returnTypeInner);
+        return { kind: 'APIReturnType', loc, type: inner.type, isArray: false, joined: inner.joined };
+    }
+    returnTypeInner(ctx) {
+        // Handle case where ctx is an array of CstNodes (from array return type)
+        if (Array.isArray(ctx)) {
+            if (ctx.length > 0) {
+                return this.visit(ctx[0]);
+            }
+            return { type: 'unknown' };
+        }
+        const baseType = this.parameterType(ctx);
+        if (ctx.objectTypeFields) {
+            const fields = this.visit(ctx.objectTypeFields);
+            const joined = fields.map(f => ({ field: f.name, entity: f.type }));
+            return { type: baseType, joined };
+        }
+        return { type: baseType };
+    }
+    objectTypeFields(ctx) {
+        return ctx.objectTypeField
+            ? ctx.objectTypeField.map((f) => this.visit(f))
+            : [];
+    }
+    objectTypeField(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const inner = this.returnTypeInner(ctx);
+        return { name, type: inner.type };
+    }
+    // Journey block visitor
+    journeyBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        let actor = '';
+        const steps = [];
+        if (ctx.journeyProperty) {
+            for (const prop of ctx.journeyProperty) {
+                const result = this.visit(prop);
+                if (result.type === 'actor')
+                    actor = result.value;
+                if (result.type === 'steps')
+                    steps.push(...result.value);
+            }
+        }
+        return {
+            kind: 'JourneyBlock',
+            loc: this.getLocation(ctx),
+            name,
+            actor,
+            steps,
+            recovery: [],
+        };
+    }
+    journeyProperty(ctx) {
+        if (ctx.Actor) {
+            return { type: 'actor', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Steps) {
+            const steps = ctx.journeyStep
+                ? ctx.journeyStep.map((s) => this.visit(s))
+                : [];
+            return { type: 'steps', value: steps };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    journeyStep(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const properties = {};
+        if (ctx.journeyStepProperty) {
+            for (const prop of ctx.journeyStepProperty) {
+                const result = this.visit(prop);
+                properties[result.type] = result.value;
+            }
+        }
+        return {
+            kind: 'JourneyStep',
+            loc: this.getLocation(ctx),
+            name,
+            page: properties.page,
+            next: properties.next,
+            waitFor: properties.waitFor,
+            action: properties.action,
+            skipIf: properties.condition,
+        };
+    }
+    journeyStepProperty(ctx) {
+        if (ctx.Page) {
+            return { type: 'page', value: (ctx.PascalIdentifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Next) {
+            return { type: 'next', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.WaitFor) {
+            return { type: 'waitFor', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Action) {
+            return { type: 'action', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Condition) {
+            return { type: 'condition', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    // Page block visitor
+    pageBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const properties = {};
+        if (ctx.pageProperty) {
+            for (const prop of ctx.pageProperty) {
+                const result = this.visit(prop);
+                properties[result.type] = result.value;
+            }
+        }
+        return {
+            kind: 'PageBlock',
+            loc: this.getLocation(ctx),
+            name,
+            route: properties.route ?? '',
+            loaders: [],
+            actions: [],
+            guard: properties.guard,
+            meta: properties.meta,
+        };
+    }
+    pageProperty(ctx) {
+        if (ctx.Route) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'route', value: value.slice(1, -1) };
+        }
+        if (ctx.Layout) {
+            return { type: 'layout', value: (ctx.PascalIdentifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Loader) {
+            return { type: 'loader', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Guard) {
+            return { type: 'guard', value: (ctx.Identifier?.[0])?.image ?? '' };
+        }
+        if (ctx.Meta) {
+            const meta = {};
+            if (ctx.metaProperty) {
+                for (const prop of ctx.metaProperty) {
+                    const result = this.visit(prop);
+                    meta[result.name] = result.value;
+                }
+            }
+            return { type: 'meta', value: meta };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    metaProperty(ctx) {
+        const name = ctx.Identifier?.[0]?.image ?? '';
+        const value = ctx.StringLiteral?.[0]?.image.slice(1, -1) ?? '';
+        return { name, value };
+    }
+    // Component block visitor
+    componentBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const props = [];
+        const state = [];
+        const handlers = [];
+        if (ctx.componentProperty) {
+            for (const prop of ctx.componentProperty) {
+                const result = this.visit(prop);
+                if (result.type === 'props')
+                    props.push(...result.value);
+                if (result.type === 'state')
+                    state.push(...result.value);
+                if (result.type === 'handlers')
+                    handlers.push(...result.value);
+            }
+        }
+        return {
+            kind: 'ComponentBlock',
+            loc: this.getLocation(ctx),
+            name,
+            props: props.map((p) => ({
+                kind: 'ComponentProp',
+                loc: this.getLocation(ctx),
+                name: p.name,
+                type: p.type,
+                optional: p.optional ?? false,
+            })),
+            variants: [],
+        };
+    }
+    componentProperty(ctx) {
+        if (ctx.Props) {
+            const props = ctx.propDefinition
+                ? ctx.propDefinition.map((p) => this.visit(p))
+                : [];
+            return { type: 'props', value: props };
+        }
+        if (ctx.State) {
+            const state = ctx.stateDefinition
+                ? ctx.stateDefinition.map((s) => this.visit(s))
+                : [];
+            return { type: 'state', value: state };
+        }
+        if (ctx.Handlers) {
+            const handlers = ctx.handlerDefinition
+                ? ctx.handlerDefinition.map((h) => this.visit(h))
+                : [];
+            return { type: 'handlers', value: handlers };
+        }
+        return { type: 'unknown', value: [] };
+    }
+    propDefinition(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const type = this.visit(ctx.parameterType);
+        const optional = !!ctx.Question;
+        return { name, type, optional };
+    }
+    stateDefinition(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const type = this.visit(ctx.parameterType);
+        const defaultValue = ctx.defaultValue ? this.visit(ctx.defaultValue) : undefined;
+        return { name, type, defaultValue };
+    }
+    handlerDefinition(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const effects = this.visit(ctx.effectAnnotation);
+        return { name, effects };
+    }
+    // Form block visitor
+    formBlock(ctx) {
+        const name = (ctx.PascalIdentifier?.[0])?.image ?? '';
+        const fields = [];
+        let submit = {};
+        let validation = {};
+        if (ctx.formProperty) {
+            for (const prop of ctx.formProperty) {
+                const result = this.visit(prop);
+                if (result.type === 'fields')
+                    fields.push(...result.value);
+                if (result.type === 'submit')
+                    submit = result.value;
+                if (result.type === 'validation')
+                    validation = result.value;
+            }
+        }
+        const submitData = submit;
+        return {
+            kind: 'FormBlock',
+            loc: this.getLocation(ctx),
+            name,
+            fields,
+            submit: {
+                kind: 'FormSubmit',
+                loc: this.getLocation(ctx),
+                action: submitData.action ?? '',
+                button: submitData.button ?? 'Submit',
+                onSuccess: submitData.onSuccess ?? 'redirect',
+                onError: submitData.onError ?? 'show_error',
+            },
+            layout: [],
+        };
+    }
+    formProperty(ctx) {
+        if (ctx.Fields) {
+            const fields = ctx.formFieldDefinition
+                ? ctx.formFieldDefinition.map((f) => this.visit(f))
+                : [];
+            return { type: 'fields', value: fields };
+        }
+        if (ctx.Submit) {
+            const submit = {};
+            if (ctx.submitProperty) {
+                for (const prop of ctx.submitProperty) {
+                    const result = this.visit(prop);
+                    submit[result.type] = result.value;
+                }
+            }
+            return { type: 'submit', value: submit };
+        }
+        if (ctx.Validation) {
+            const validation = {};
+            if (ctx.validationRule) {
+                for (const rule of ctx.validationRule) {
+                    const result = this.visit(rule);
+                    validation[result.name] = result.value;
+                }
+            }
+            return { type: 'validation', value: validation };
+        }
+        return { type: 'unknown', value: {} };
+    }
+    formFieldDefinition(ctx) {
+        const name = (ctx.Identifier?.[0])?.image ?? '';
+        const fieldType = this.visit(ctx.formFieldType);
+        const properties = {};
+        if (ctx.formFieldProperty) {
+            for (const prop of ctx.formFieldProperty) {
+                const result = this.visit(prop);
+                properties[result.type] = result.value;
+            }
+        }
+        return {
+            kind: 'FormField',
+            loc: this.getLocation(ctx),
+            name,
+            type: fieldType,
+            label: properties.label ?? name,
+            placeholder: properties.placeholder,
+            required: properties.required ?? false,
+            config: properties.rows ? { rows: properties.rows } : undefined,
+            options: properties.options
+                ? properties.options.map((opt) => ({
+                    kind: 'FormFieldOption',
+                    loc: this.getLocation(ctx),
+                    value: opt,
+                    label: opt,
+                }))
+                : undefined,
+        };
+    }
+    formFieldType(ctx) {
+        if (ctx.Text)
+            return 'text';
+        if (ctx.Textarea)
+            return 'textarea';
+        if (ctx.Email)
+            return 'email';
+        if (ctx.Password)
+            return 'password';
+        if (ctx.Number)
+            return 'number';
+        if (ctx.Checkbox)
+            return 'checkbox';
+        if (ctx.Radio)
+            return 'radio';
+        if (ctx.Select)
+            return 'select';
+        if (ctx.Date)
+            return 'date';
+        if (ctx.File)
+            return 'file';
+        return 'text';
+    }
+    formFieldProperty(ctx) {
+        if (ctx.Label) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'label', value: value.slice(1, -1) };
+        }
+        if (ctx.Placeholder) {
+            const value = (ctx.StringLiteral?.[0])?.image ?? '';
+            return { type: 'placeholder', value: value.slice(1, -1) };
+        }
+        if (ctx.Required) {
+            return { type: 'required', value: !!ctx.True };
+        }
+        if (ctx.Rows) {
+            return { type: 'rows', value: parseInt((ctx.IntegerLiteral?.[0])?.image ?? '4', 10) };
+        }
+        if (ctx.Options) {
+            const options = (ctx.StringLiteral ?? []).map((t) => t.image.slice(1, -1));
+            return { type: 'options', value: options };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    submitProperty(ctx) {
+        if (ctx.Action) {
+            const parts = (ctx.Identifier ?? []).map((t) => t.image);
+            return { type: 'action', value: parts.join('.') };
+        }
+        if (ctx.Button) {
+            return { type: 'button', value: ctx.StringLiteral?.[0]?.image.slice(1, -1) ?? '' };
+        }
+        if (ctx.OnSuccess) {
+            return { type: 'onSuccess', value: ctx.Identifier?.[0]?.image ?? '' };
+        }
+        if (ctx.OnError) {
+            return { type: 'onError', value: ctx.Identifier?.[0]?.image ?? '' };
+        }
+        return { type: 'unknown', value: '' };
+    }
+    validationRule(ctx) {
+        const identifiers = ctx.Identifier ?? [];
+        return {
+            name: identifiers[0]?.image ?? '',
+            value: identifiers[1]?.image ?? '',
+        };
+    }
+    // Design block visitor
+    designBlock(ctx) {
+        const colorsMap = {};
+        let darkColorsMap;
+        let typography;
+        let spacing;
+        let motion;
+        if (ctx.designSection) {
+            for (const section of ctx.designSection) {
+                const result = this.visit(section);
+                if (result.type === 'colors') {
+                    for (const [key, value] of Object.entries(result.value)) {
+                        colorsMap[key] = { value, isFunction: false };
+                    }
+                }
+                if (result.type === 'dark') {
+                    darkColorsMap = {};
+                    for (const [key, value] of Object.entries(result.value)) {
+                        darkColorsMap[key] = { value, isFunction: false };
+                    }
+                }
+                if (result.type === 'typography')
+                    typography = result.value;
+                if (result.type === 'spacing')
+                    spacing = result.value;
+                if (result.type === 'animation')
+                    motion = result.value;
+            }
+        }
+        return {
+            kind: 'DesignBlock',
+            loc: this.getLocation(ctx),
+            colors: {
+                kind: 'ColorPalette',
+                loc: this.getLocation(ctx),
+                colors: colorsMap,
+            },
+            darkColors: darkColorsMap
+                ? {
+                    kind: 'ColorPalette',
+                    loc: this.getLocation(ctx),
+                    colors: darkColorsMap,
+                }
+                : undefined,
+            typography,
+            spacing,
+            motion,
+        };
+    }
+    designSection(ctx) {
+        if (ctx.Colors) {
+            const colors = {};
+            if (ctx.colorDefinition) {
+                for (const def of ctx.colorDefinition) {
+                    const result = this.visit(def);
+                    colors[result.name] = result.value;
+                }
+            }
+            return { type: 'colors', value: colors };
+        }
+        if (ctx.Dark) {
+            const colors = {};
+            if (ctx.colorDefinition) {
+                for (const def of ctx.colorDefinition) {
+                    const result = this.visit(def);
+                    colors[result.name] = result.value;
+                }
+            }
+            return { type: 'dark', value: colors };
+        }
+        if (ctx.Typography) {
+            const typography = {};
+            if (ctx.typographyDefinition) {
+                for (const def of ctx.typographyDefinition) {
+                    const result = this.visit(def);
+                    typography[result.name] = result.value;
+                }
+            }
+            return { type: 'typography', value: typography };
+        }
+        if (ctx.Spacing) {
+            const spacing = {};
+            if (ctx.spacingDefinition) {
+                for (const def of ctx.spacingDefinition) {
+                    const result = this.visit(def);
+                    spacing[result.name] = result.value;
+                }
+            }
+            return { type: 'spacing', value: spacing };
+        }
+        if (ctx.Animation) {
+            const animation = {};
+            if (ctx.animationDefinition) {
+                for (const def of ctx.animationDefinition) {
+                    const result = this.visit(def);
+                    animation[result.name] = result.value;
+                }
+            }
+            return { type: 'animation', value: animation };
+        }
+        return { type: 'unknown', value: {} };
+    }
+    colorDefinition(ctx) {
+        const fieldNameNode = ctx.fieldName?.[0];
+        const hexColorToken = ctx.HexColor?.[0];
+        return {
+            name: fieldNameNode ? this.visit(fieldNameNode) : '',
+            value: hexColorToken?.image ?? '',
+        };
+    }
+    typographyDefinition(ctx) {
+        const name = ctx.Identifier?.[0]?.image ?? '';
+        let value = '';
+        if (ctx.StringLiteral)
+            value = ctx.StringLiteral[0].image.slice(1, -1);
+        else if (ctx.SizeLiteral)
+            value = ctx.SizeLiteral[0].image;
+        else if (ctx.IntegerLiteral)
+            value = ctx.IntegerLiteral[0].image;
+        return { name, value };
+    }
+    spacingDefinition(ctx) {
+        return {
+            name: ctx.Identifier?.[0]?.image ?? '',
+            value: ctx.SizeLiteral?.[0]?.image ?? '',
+        };
+    }
+    animationDefinition(ctx) {
+        const name = ctx.Identifier?.[0]?.image ?? '';
+        let value = '';
+        if (ctx.DurationLiteral)
+            value = ctx.DurationLiteral[0].image;
+        else if (ctx.CSSFunctionLiteral)
+            value = ctx.CSSFunctionLiteral[0].image;
+        else if (ctx.StringLiteral)
+            value = ctx.StringLiteral[0].image.slice(1, -1);
+        return { name, value };
+    }
+}
+// =============================================================================
+// Parse Function
+// =============================================================================
+const astBuilder = new KappaAstBuilder();
+export function parse(source) {
+    // Tokenize
+    const lexResult = tokens.tokenize(source);
+    if (!lexResult.success) {
+        return {
+            success: false,
+            errors: lexResult.errors.map((e) => ({
+                message: e.message,
+                line: e.line,
+                column: e.column,
+            })),
+        };
+    }
+    // Parse
+    parser.input = lexResult.tokens;
+    const cst = parser.kappaSpec();
+    if (parser.errors.length > 0) {
+        return {
+            success: false,
+            errors: parser.errors.map((e) => ({
+                message: e.message,
+                line: e.token.startLine,
+                column: e.token.startColumn,
+            })),
+        };
+    }
+    // Build AST
+    const ast = astBuilder.visit(cst);
+    return {
+        success: true,
+        ast,
+        errors: [],
+    };
+}
+/**
+ * Convenience function that parses source and returns the AST directly.
+ * Returns null if parsing fails.
+ */
+export function parseToAST(source) {
+    const result = parse(source);
+    return result.success ? result.ast ?? null : null;
+}
+export { parser, KappaParser, KappaAstBuilder };