tova 0.5.0 → 0.7.0

package/src/analyzer/analyzer.js

@@ -1,8 +1,7 @@
 import { Scope, Symbol } from './scope.js';
 import { PIPE_TARGET } from '../parser/ast.js';
 import { BUILTIN_NAMES } from '../stdlib/inline.js';
-import { collectServerBlockFunctions, installServerAnalyzer } from './server-analyzer.js';
-import { installClientAnalyzer } from './client-analyzer.js';
+import { BlockRegistry } from '../registry/register-all.js';
 import {
   Type, PrimitiveType, NilType, AnyType, UnknownType,
   ArrayType, TupleType, FunctionType, RecordType, ADTType,
@@ -98,7 +97,7 @@ function levenshtein(a, b) {
 
 const _TOVA_RUNTIME = new Set([
   'Ok', 'Err', 'Some', 'None', 'Result', 'Option',
-  'db', 'server', 'client', 'shared',
+  'db', 'server', 'browser', 'client', 'shared',
 ]);
 
 // Pre-built static candidate set for Levenshtein suggestions (N1 optimization)
@@ -327,19 +326,17 @@ export class Analyzer {
   }
 
   analyze() {
-    // Pre-pass: collect named server block functions for inter-server RPC validation
-    const hasServerBlocks = this.ast.body.some(n => n.type === 'ServerBlock');
-    if (hasServerBlocks) {
-      installServerAnalyzer(Analyzer);
-      this.serverBlockFunctions = collectServerBlockFunctions(this.ast);
-    } else {
-      this.serverBlockFunctions = new Map();
+    // Pre-pass hooks (e.g., server block function collection for RPC validation)
+    for (const plugin of BlockRegistry.all()) {
+      if (plugin.analyzer?.prePass) plugin.analyzer.prePass(this);
     }
 
     this.visitProgram(this.ast);
 
-    // Cross-block security validation (after all blocks are visited)
-    this._validateSecurityCrossBlock();
+    // Post-visit cross-block validation
+    for (const plugin of BlockRegistry.all()) {
+      if (plugin.analyzer?.crossBlockValidate) plugin.analyzer.crossBlockValidate(this);
+    }
 
     // Check for unused variables/imports (#9)
     this._collectAllScopes(this.globalScope);
@@ -732,43 +729,14 @@ export class Analyzer {
   visitNode(node) {
     if (!node) return;
 
+    // Single registry lookup: returns plugin, NOOP sentinel, or null
+    const entry = BlockRegistry.getByAstType(node.type);
+    if (entry) {
+      if (entry === BlockRegistry.NOOP) return;
+      if (entry.analyzer?.visit) return entry.analyzer.visit(this, node);
+    }
+
     switch (node.type) {
-      case 'ServerBlock':
-      case 'RouteDeclaration':
-      case 'MiddlewareDeclaration':
-      case 'HealthCheckDeclaration':
-      case 'CorsDeclaration':
-      case 'ErrorHandlerDeclaration':
-      case 'WebSocketDeclaration':
-      case 'StaticDeclaration':
-      case 'DiscoverDeclaration':
-      case 'AuthDeclaration':
-      case 'MaxBodyDeclaration':
-      case 'RouteGroupDeclaration':
-      case 'RateLimitDeclaration':
-      case 'LifecycleHookDeclaration':
-      case 'SubscribeDeclaration':
-      case 'EnvDeclaration':
-      case 'ScheduleDeclaration':
-      case 'UploadDeclaration':
-      case 'SessionDeclaration':
-      case 'DbDeclaration':
-      case 'TlsDeclaration':
-      case 'CompressionDeclaration':
-      case 'BackgroundJobDeclaration':
-      case 'CacheDeclaration':
-      case 'SseDeclaration':
-      case 'ModelDeclaration':
-        return this._visitServerNode(node);
-      case 'AiConfigDeclaration': return; // handled at block level
-      case 'ClientBlock':
-      case 'StateDeclaration':
-      case 'ComputedDeclaration':
-      case 'EffectDeclaration':
-      case 'ComponentDeclaration':
-      case 'StoreDeclaration':
-        return this._visitClientNode(node);
-      case 'SharedBlock': return this.visitSharedBlock(node);
       case 'Assignment': return this.visitAssignment(node);
       case 'VarDeclaration': return this.visitVarDeclaration(node);
       case 'LetDestructure': return this.visitLetDestructure(node);
@@ -790,24 +758,7 @@ export class Analyzer {
       case 'ContinueStatement': return this.visitContinueStatement(node);
       case 'GuardStatement': return this.visitGuardStatement(node);
       case 'InterfaceDeclaration': return this.visitInterfaceDeclaration(node);
-      case 'DataBlock': return this.visitDataBlock(node);
-      case 'SecurityBlock': return this.visitSecurityBlock(node);
-      case 'SecurityAuthDeclaration': return;
-      case 'SecurityRoleDeclaration': return;
-      case 'SecurityProtectDeclaration': return;
-      case 'SecuritySensitiveDeclaration': return;
-      case 'SecurityCorsDeclaration': return;
-      case 'SecurityCspDeclaration': return;
-      case 'SecurityRateLimitDeclaration': return;
-      case 'SecurityCsrfDeclaration': return;
-      case 'SecurityAuditDeclaration': return;
-      case 'SourceDeclaration': return;
-      case 'PipelineDeclaration': return;
-      case 'ValidateBlock': return;
-      case 'RefreshPolicy': return;
       case 'RefinementType': return;
-      case 'TestBlock': return this.visitTestBlock(node);
-      case 'BenchBlock': return this.visitTestBlock(node);
       case 'ComponentStyleBlock': return; // raw CSS — no analysis needed
       case 'ImplDeclaration': return this.visitImplDeclaration(node);
       case 'TraitDeclaration': return this.visitTraitDeclaration(node);
@@ -821,19 +772,14 @@ export class Analyzer {
   }
 
   _visitServerNode(node) {
-    if (!Analyzer.prototype._serverAnalyzerInstalled) {
-      installServerAnalyzer(Analyzer);
-    }
     const methodName = 'visit' + node.type;
     return this[methodName](node);
   }
 
-  _visitClientNode(node) {
-    if (!Analyzer.prototype._clientAnalyzerInstalled) {
-      installClientAnalyzer(Analyzer);
-    }
-    const methodName = 'visit' + node.type;
-    return this[methodName](node);
+  _visitBrowserNode(node) {
+    // Ensure browser analyzer is installed (may be called from visitExpression for JSX)
+    const plugin = BlockRegistry.get('browser');
+    return plugin.analyzer.visit(this, node);
   }
 
   visitExpression(node) {
@@ -971,7 +917,7 @@ export class Analyzer {
         return;
       case 'JSXElement':
       case 'JSXFragment':
-        return this._visitClientNode(node);
+        return this._visitBrowserNode(node);
       // Column expressions (for table operations) — no semantic analysis needed
       case 'ColumnExpression':
         return;
@@ -1021,6 +967,296 @@ export class Analyzer {
     }
   }
 
+  visitCliBlock(node) {
+    const validKeys = new Set(['name', 'version', 'description']);
+
+    // Validate config keys
+    for (const field of node.config) {
+      if (!validKeys.has(field.key)) {
+        this.warnings.push({
+          message: `Unknown cli config key '${field.key}' — valid keys are: ${[...validKeys].join(', ')}`,
+          loc: field.loc,
+          code: 'W_UNKNOWN_CLI_CONFIG',
+        });
+      }
+    }
+
+    // Validate commands
+    const commandNames = new Set();
+    for (const cmd of node.commands) {
+      // Duplicate command names
+      if (commandNames.has(cmd.name)) {
+        this.warnings.push({
+          message: `Duplicate cli command '${cmd.name}'`,
+          loc: cmd.loc,
+          code: 'W_DUPLICATE_CLI_COMMAND',
+        });
+      }
+      commandNames.add(cmd.name);
+
+      // Check for positional args after flags
+      let seenFlag = false;
+      for (const param of cmd.params) {
+        if (param.isFlag) {
+          seenFlag = true;
+        } else if (seenFlag) {
+          this.warnings.push({
+            message: `Positional argument '${param.name}' after flag in command '${cmd.name}' — positionals should come before flags`,
+            loc: param.loc,
+            code: 'W_POSITIONAL_AFTER_FLAG',
+          });
+        }
+      }
+
+      // Visit command body with params in scope
+      this.pushScope('function');
+      for (const param of cmd.params) {
+        this.currentScope.define(param.name,
+          new Symbol(param.name, 'parameter', null, false, param.loc));
+      }
+      this.visitNode(cmd.body);
+      this.popScope();
+    }
+  }
+
+  _validateCliCrossBlock() {
+    const cliBlocks = this.ast.body.filter(n => n.type === 'CliBlock');
+    if (cliBlocks.length === 0) return;
+
+    // Warn if cli + server coexist
+    const hasServer = this.ast.body.some(n => n.type === 'ServerBlock');
+    if (hasServer) {
+      this.warnings.push({
+        message: 'cli {} and server {} blocks in the same file — cli produces a standalone executable, not a web server',
+        loc: cliBlocks[0].loc,
+        code: 'W_CLI_WITH_SERVER',
+      });
+    }
+
+    // Check for missing name across all cli blocks
+    let hasName = false;
+    for (const block of cliBlocks) {
+      for (const field of block.config) {
+        if (field.key === 'name') hasName = true;
+      }
+    }
+    if (!hasName) {
+      this.warnings.push({
+        message: 'cli block has no name: field — consider adding name: "your-tool"',
+        loc: cliBlocks[0].loc,
+        code: 'W_CLI_MISSING_NAME',
+      });
+    }
+  }
+
+  visitEdgeBlock(node) {
+    const validTargets = new Set(['cloudflare', 'deno', 'vercel', 'lambda', 'bun']);
+    const validConfigKeys = new Set(['target']);
+    const bindingNames = new Set();
+
+    // Binding support matrix per target
+    const BINDING_SUPPORT = {
+      cloudflare: { kv: true, sql: true, storage: true, queue: true },
+      deno:       { kv: true, sql: false, storage: false, queue: false },
+      vercel:     { kv: false, sql: false, storage: false, queue: false },
+      lambda:     { kv: false, sql: false, storage: false, queue: false },
+      bun:        { kv: false, sql: true, storage: false, queue: false },
+    };
+
+    // Targets that support schedule/consume/middleware
+    const SCHEDULE_TARGETS = new Set(['cloudflare', 'deno']);
+    const CONSUME_TARGETS = new Set(['cloudflare']);
+
+    // Determine target from config fields
+    let target = 'cloudflare';
+    for (const stmt of node.body) {
+      if (stmt.type === 'EdgeConfigField' && stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+        target = stmt.value.value;
+      }
+    }
+
+    this.pushScope('edge');
+
+    let kvCount = 0;
+    const queueNames = new Set();
+    const consumers = [];
+
+    for (const stmt of node.body) {
+      // Validate config fields
+      if (stmt.type === 'EdgeConfigField') {
+        if (!validConfigKeys.has(stmt.key)) {
+          this.warnings.push({
+            message: `Unknown edge config key '${stmt.key}' — valid keys are: ${[...validConfigKeys].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNKNOWN_EDGE_CONFIG',
+          });
+        }
+        if (stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+          if (!validTargets.has(stmt.value.value)) {
+            this.warnings.push({
+              message: `Unknown edge target '${stmt.value.value}' — valid targets are: ${[...validTargets].join(', ')}`,
+              loc: stmt.loc,
+              code: 'W_UNKNOWN_EDGE_TARGET',
+            });
+          }
+        }
+        continue;
+      }
+
+      // Check for duplicate binding names
+      if (stmt.type === 'EdgeKVDeclaration' || stmt.type === 'EdgeSQLDeclaration' ||
+          stmt.type === 'EdgeStorageDeclaration' || stmt.type === 'EdgeQueueDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Track queue names for consume validation
+      if (stmt.type === 'EdgeQueueDeclaration') {
+        queueNames.add(stmt.name);
+      }
+
+      // Check for duplicate env/secret names
+      if (stmt.type === 'EdgeEnvDeclaration' || stmt.type === 'EdgeSecretDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Unsupported binding warnings (per target)
+      const support = BINDING_SUPPORT[target] || BINDING_SUPPORT.cloudflare;
+      if (stmt.type === 'EdgeKVDeclaration' && !support.kv) {
+        this.warnings.push({
+          message: `KV binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_KV',
+        });
+      }
+      if (stmt.type === 'EdgeSQLDeclaration' && !support.sql) {
+        this.warnings.push({
+          message: `SQL binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_SQL',
+        });
+      }
+      if (stmt.type === 'EdgeStorageDeclaration' && !support.storage) {
+        this.warnings.push({
+          message: `Storage binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_STORAGE',
+        });
+      }
+      if (stmt.type === 'EdgeQueueDeclaration' && !support.queue) {
+        this.warnings.push({
+          message: `Queue binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_QUEUE',
+        });
+      }
+
+      // Deno multi-KV warning
+      if (stmt.type === 'EdgeKVDeclaration') {
+        kvCount++;
+        if (kvCount > 1 && target === 'deno') {
+          this.warnings.push({
+            message: `Deno Deploy supports only one KV store — '${stmt.name}' will share the same store as the first KV binding`,
+            loc: stmt.loc,
+            code: 'W_DENO_MULTI_KV',
+          });
+        }
+      }
+
+      // Validate schedule cron expressions + target support
+      if (stmt.type === 'EdgeScheduleDeclaration') {
+        const parts = stmt.cron.split(/\s+/);
+        if (parts.length < 5 || parts.length > 6) {
+          this.warnings.push({
+            message: `Invalid cron expression '${stmt.cron}' — expected 5 or 6 space-separated fields`,
+            loc: stmt.loc,
+            code: 'W_INVALID_CRON',
+          });
+        }
+        if (!SCHEDULE_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Scheduled tasks are not supported on target '${target}' — schedule '${stmt.name}' will be ignored. Supported targets: ${[...SCHEDULE_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_SCHEDULE',
+          });
+        }
+      }
+
+      // Collect consume declarations for post-loop validation
+      if (stmt.type === 'EdgeConsumeDeclaration') {
+        consumers.push(stmt);
+        if (!CONSUME_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Queue consumers are not supported on target '${target}' — consume '${stmt.queue}' will be ignored. Supported targets: ${[...CONSUME_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_CONSUME',
+          });
+        }
+      }
+
+      // Visit child nodes — edge-specific types are noop in the registry,
+      // so explicitly visit bodies that contain statements
+      if (stmt.type === 'EdgeScheduleDeclaration' && stmt.body) {
+        for (const s of stmt.body.body || []) this.visitNode(s);
+      } else if (stmt.type === 'FunctionDeclaration' || stmt.type === 'RouteDeclaration') {
+        this.visitNode(stmt);
+      }
+    }
+
+    // Post-loop: validate consume references a declared queue
+    for (const consumer of consumers) {
+      if (!queueNames.has(consumer.queue)) {
+        this.warnings.push({
+          message: `consume '${consumer.queue}' references undeclared queue binding — add 'queue ${consumer.queue}' to the edge block`,
+          loc: consumer.loc,
+          code: 'W_CONSUME_UNKNOWN_QUEUE',
+        });
+      }
+    }
+
+    // Warn if edge block has no route or schedule handlers
+    const hasRoutes = node.body.some(s => s.type === 'RouteDeclaration');
+    const hasSchedules = node.body.some(s => s.type === 'EdgeScheduleDeclaration');
+    const hasConsumers = consumers.length > 0;
+    if (!hasRoutes && !hasSchedules && !hasConsumers) {
+      this.warnings.push({
+        message: 'edge block has no routes, schedules, or consumers — it will produce no handlers',
+        loc: node.loc,
+        code: 'W_EDGE_NO_HANDLERS',
+      });
+    }
+
+    this.popScope();
+  }
+
+  _validateEdgeCrossBlock() {
+    const edgeBlocks = this.ast.body.filter(n => n.type === 'EdgeBlock');
+    if (edgeBlocks.length === 0) return;
+
+    // Warn if edge + cli coexist (cli takes over with earlyReturn)
+    const hasCli = this.ast.body.some(n => n.type === 'CliBlock');
+    if (hasCli) {
+      this.warnings.push({
+        message: 'edge {} and cli {} blocks in the same file — cli produces a standalone executable, edge block will be ignored',
+        loc: edgeBlocks[0].loc,
+        code: 'W_EDGE_WITH_CLI',
+      });
+    }
+  }
+
   _validateSecurityCrossBlock() {
     // Collect ALL security declarations across ALL security blocks in the AST
     const allRoles = new Set();
@@ -1259,7 +1495,7 @@ export class Analyzer {
     }
   }
 
-  // visitClientBlock and other client visitors are in client-analyzer.js (lazy-loaded)
+  // visitBrowserBlock and other browser visitors are in browser-analyzer.js (lazy-loaded)
 
   visitSharedBlock(node) {
     const prevScope = this.currentScope;
@@ -1959,7 +2195,7 @@ export class Analyzer {
     this.visitExpression(node.value);
   }
 
-  // Client-specific visitors (visitState, visitComputed, etc.) are in client-analyzer.js (lazy-loaded)
+  // Browser-specific visitors (visitState, visitComputed, etc.) are in browser-analyzer.js (lazy-loaded)
 
   visitTestBlock(node) {
     const prevScope = this.currentScope;
@@ -2324,7 +2560,7 @@ export class Analyzer {
           candidates.push([node.name, typeVariants]);
         }
       }
-      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'BrowserBlock') {
         this._collectTypeCandidates(node.body, coveredVariants, candidates);
       }
     }
@@ -2419,7 +2655,7 @@ export class Analyzer {
     }
   }
 
-  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in client-analyzer.js (lazy-loaded)
+  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in browser-analyzer.js (lazy-loaded)
 
   // ─── New feature visitors ─────────────────────────────────
 

package/src/analyzer/{client-analyzer.js → browser-analyzer.js}

@@ -1,15 +1,18 @@
-// Client-specific analyzer methods for the Tova language
-// Extracted from analyzer.js for lazy loading — only loaded when client { } blocks are encountered.
+// Browser-specific analyzer methods for the Tova language
+// Extracted from analyzer.js for lazy loading — only loaded when browser { } blocks are encountered.
 
 import { Symbol } from './scope.js';
+import { installFormAnalyzer } from './form-analyzer.js';
 
-export function installClientAnalyzer(AnalyzerClass) {
-  if (AnalyzerClass.prototype._clientAnalyzerInstalled) return;
-  AnalyzerClass.prototype._clientAnalyzerInstalled = true;
+export function installBrowserAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._browserAnalyzerInstalled) return;
+  AnalyzerClass.prototype._browserAnalyzerInstalled = true;
 
-  AnalyzerClass.prototype.visitClientBlock = function(node) {
+  installFormAnalyzer(AnalyzerClass);
+
+  AnalyzerClass.prototype.visitBrowserBlock = function(node) {
     const prevScope = this.currentScope;
-    this.currentScope = this.currentScope.child('client');
+    this.currentScope = this.currentScope.child('browser');
     try {
       for (const stmt of node.body) {
         this.visitNode(stmt);
@@ -21,8 +24,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStateDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'state' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'state' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -35,8 +38,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitComputedDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'computed' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'computed' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -49,16 +52,16 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitEffectDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'effect' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'effect' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this.visitNode(node.body);
   };
 
   AnalyzerClass.prototype.visitComponentDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'component' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'component' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this._checkNamingConvention(node.name, 'component', node.loc);
     try {
@@ -89,8 +92,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStoreDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'store' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'store' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this._checkNamingConvention(node.name, 'store', node.loc);
     try {

package/src/analyzer/form-analyzer.js

@@ -0,0 +1,113 @@
+// Form-specific analyzer methods for the Tova language
+// Extracted for lazy loading — only loaded when form { } blocks are encountered.
+
+import { Symbol } from './scope.js';
+
+export function installFormAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._formAnalyzerInstalled) return;
+  AnalyzerClass.prototype._formAnalyzerInstalled = true;
+
+  const KNOWN_VALIDATORS = new Set([
+    'required', 'minLength', 'maxLength', 'min', 'max',
+    'pattern', 'email', 'matches', 'oneOf', 'validate',
+  ]);
+
+  AnalyzerClass.prototype.visitFormDeclaration = function(node) {
+    const ctx = this.currentScope.getContext();
+    if (ctx !== 'browser') {
+      this.error(`'form' can only be used inside a browser block or component`, node.loc,
+        "move this inside a browser { } block", { code: 'E310' });
+    }
+
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'form', node.typeAnnotation, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('form');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+      for (const group of node.groups) { this._visitFormGroup(group); }
+      for (const arr of node.arrays) { this._visitFormArray(arr); }
+      for (const comp of node.computeds) { this.visitNode(comp); }
+      if (node.steps) { this._visitFormSteps(node, node.steps); }
+      if (node.onSubmit) { this.visitNode(node.onSubmit); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormField = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formField', node.typeAnnotation, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    if (node.initialValue) {
+      this.visitExpression(node.initialValue);
+    }
+    for (const v of node.validators) {
+      if (!KNOWN_VALIDATORS.has(v.name)) {
+        this.warn(`Unknown validator '${v.name}'`, v.loc, null, { code: 'W_UNKNOWN_VALIDATOR' });
+      }
+      for (const arg of v.args) {
+        this.visitExpression(arg);
+      }
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormGroup = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formGroup', null, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    if (node.condition) {
+      this.visitExpression(node.condition);
+    }
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('block');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+      for (const group of node.groups) { this._visitFormGroup(group); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormArray = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formArray', null, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('block');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormSteps = function(formNode, stepsNode) {
+    const knownMembers = new Set();
+    for (const f of formNode.fields) knownMembers.add(f.name);
+    for (const g of formNode.groups) knownMembers.add(g.name);
+    for (const a of formNode.arrays) knownMembers.add(a.name);
+
+    for (const step of stepsNode.steps) {
+      for (const member of step.members) {
+        if (!knownMembers.has(member)) {
+          this.warn(`Step '${step.label}' references unknown member '${member}'`, step.loc, null, { code: 'W_STEP_UNKNOWN_MEMBER' });
+        }
+      }
+    }
+  };
+}