@holoscript/core 8.0.8 → 8.0.10

package/dist/{chunk-FNHJRI32.js → chunk-DBH3D2MU.js}

@@ -1,7 +1,34 @@
-import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-VSACG2AR.js';
-import { VR_TRAITS } from './chunk-GASCWJK5.js';
+import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions } from './chunk-Z6LZUYZF.js';
+import { isBrainKeyword, isCognitiveVerb, nearestCognitiveVerb } from './chunk-UNMVGZVW.js';
+import { LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-JBYBMBMW.js';
+import { VR_TRAITS } from './chunk-2EGGAZT3.js';
+import { isLocomotionReactionTrigger } from './chunk-63AUAIL6.js';
 import * as crypto from 'crypto';
 
+// src/traits/FrameDeclarationTrait.ts
+var DEFAULT_FRAME = {
+  domain: "*",
+  horizon: "",
+  capability_tier: 2,
+  trust_tier: 2};
+function coerceConfig(raw) {
+  const domain = typeof raw.domain === "string" ? raw.domain : DEFAULT_FRAME.domain;
+  const horizon = typeof raw.horizon === "string" ? raw.horizon : DEFAULT_FRAME.horizon;
+  let capability_tier = DEFAULT_FRAME.capability_tier;
+  const rawCT = raw.capability_tier;
+  if (rawCT === 0 || rawCT === 1 || rawCT === 2 || rawCT === 3) {
+    capability_tier = rawCT;
+  }
+  let trust_tier = DEFAULT_FRAME.trust_tier;
+  const rawTT = raw.trust_tier;
+  if (rawTT === 0 || rawTT === 1 || rawTT === 2 || rawTT === 3) {
+    trust_tier = rawTT;
+  }
+  const allowed_tools = Array.isArray(raw.allowed_tools) ? raw.allowed_tools.filter((t) => typeof t === "string") : [];
+  const denied_domains = Array.isArray(raw.denied_domains) ? raw.denied_domains.filter((d) => typeof d === "string") : [];
+  return { domain, horizon, capability_tier, trust_tier, allowed_tools, denied_domains };
+}
+
 // src/parser/HybridChunker.ts
 function countTokens(text) {
   return Math.ceil(text.length / 4);
@@ -1142,13 +1169,18 @@ var Lexer = class {
         this.tokens.push(this.createToken("DEDENT", ""));
         this.pendingDedents--;
       }
+      if (this.column === 1) {
+        const beforePos = this.pos;
+        const beforeTokenCount = this.tokens.length;
+        const beforePendingDedents = this.pendingDedents;
+        this.handleIndentation();
+        if (this.pos !== beforePos || this.tokens.length !== beforeTokenCount || this.pendingDedents !== beforePendingDedents) {
+          continue;
+        }
+      }
       const char = this.source[this.pos];
       if (char === " " || char === "	") {
-        if (this.column === 1) {
-          this.handleIndentation();
-        } else {
-          this.advance();
-        }
+        this.advance();
         continue;
       }
       if (char === "/" && this.peek(1) === "/") {
@@ -1754,13 +1786,15 @@ var Lexer = class {
     return this.isIdentifierStart(char) || this.isDigit(char) || char === "-";
   }
 };
-var HoloScriptPlusParser = class {
+var HoloScriptPlusParser = class _HoloScriptPlusParser {
   constructor(options = {}) {
     this.tokens = [];
     this.pos = 0;
     this.source = "";
     this.errors = [];
     this.warnings = [];
+    this.blockConfigDirectives = /* @__PURE__ */ new WeakSet();
+    this.blockConfigDirectiveLocations = /* @__PURE__ */ new WeakMap();
     this.imports = [];
     this.hasState = false;
     this.hasVRTraits = false;
@@ -1829,6 +1863,8 @@ var HoloScriptPlusParser = class {
     this.source = source;
     this.errors = [];
     this.warnings = [];
+    this.blockConfigDirectives = /* @__PURE__ */ new WeakSet();
+    this.blockConfigDirectiveLocations = /* @__PURE__ */ new WeakMap();
     this.imports = [];
     this.hasState = false;
     this.hasVRTraits = false;
@@ -1839,8 +1875,110 @@ var HoloScriptPlusParser = class {
     const lexer = new Lexer(source);
     this.tokens = lexer.tokenize();
     const root = this.parseDocument();
+    this.desugarSafeDaemon(root);
     return this.buildResult(root);
   }
+  /** Canonical safety-trait configs that `@safe_daemon` expands into. */
+  static safeDaemonDefaults() {
+    return {
+      rate_limiter: { strategy: "token_bucket", max_tokens: 20, refill_rate: 4, window_ms: 6e4 },
+      circuit_breaker: {
+        failure_threshold: 5,
+        window_ms: 3e5,
+        reset_timeout_ms: 6e5,
+        success_threshold: 2,
+        failure_rate_threshold: 0,
+        min_requests: 5
+      },
+      timeout_guard: { default_timeout_ms: 3e4, fallback_action: "abort" },
+      economy: {
+        initial_balance: 5,
+        default_spend_limit: 1,
+        spend_limit_period: 36e5,
+        max_transaction_history: 200,
+        escrow_enabled: false
+      },
+      structured_logger: {
+        min_level: "info",
+        max_entries: 500,
+        rotation_count: 100,
+        emit_events: true,
+        console_output: true
+      }
+    };
+  }
+  /**
+   * Expand a `@safe_daemon { ... }` config into the five safety traits it
+   * stands for (@rate_limiter + @circuit_breaker + @timeout_guard + @economy +
+   * @structured_logger). Supports flat convenience overrides (budget / rate /
+   * timeout_ms / …) and nested per-trait overrides (economy: { ... }).
+   */
+  expandSafeDaemon(config) {
+    const c = config && typeof config === "object" ? config : {};
+    const out = _HoloScriptPlusParser.safeDaemonDefaults();
+    const num = (v) => typeof v === "number";
+    if (num(c.budget)) out.economy.initial_balance = c.budget;
+    if (num(c.spend_limit)) out.economy.default_spend_limit = c.spend_limit;
+    if (num(c.rate)) out.rate_limiter.refill_rate = c.rate;
+    if (num(c.max_tokens)) out.rate_limiter.max_tokens = c.max_tokens;
+    if (num(c.window_ms)) out.rate_limiter.window_ms = c.window_ms;
+    if (num(c.failure_threshold)) out.circuit_breaker.failure_threshold = c.failure_threshold;
+    if (num(c.reset_timeout_ms)) out.circuit_breaker.reset_timeout_ms = c.reset_timeout_ms;
+    if (num(c.timeout_ms)) out.timeout_guard.default_timeout_ms = c.timeout_ms;
+    if (typeof c.log_level === "string") out.structured_logger.min_level = c.log_level;
+    for (const t of ["rate_limiter", "circuit_breaker", "timeout_guard", "economy", "structured_logger"]) {
+      const override = c[t];
+      if (override && typeof override === "object") Object.assign(out[t], override);
+    }
+    return Object.entries(out);
+  }
+  /**
+   * Walk the parsed AST and expand every `@safe_daemon` into its five safety
+   * traits, wherever traits are stored: a node's `traits` Map (composition /
+   * world / object), a brain's `traits` Record, and any `directives` array.
+   * Existing per-trait declarations are not overwritten.
+   */
+  desugarSafeDaemon(root) {
+    const seen = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (!node || typeof node !== "object" || seen.has(node)) return;
+      seen.add(node);
+      const n = node;
+      if (n.traits instanceof Map && n.traits.has("safe_daemon")) {
+        const cfg = n.traits.get("safe_daemon");
+        n.traits.delete("safe_daemon");
+        for (const [name, c] of this.expandSafeDaemon(cfg)) {
+          if (!n.traits.has(name)) n.traits.set(name, c);
+        }
+        this.hasVRTraits = true;
+      }
+      if (n.traits && !(n.traits instanceof Map) && typeof n.traits === "object") {
+        const rec = n.traits;
+        if ("safe_daemon" in rec) {
+          const cfg = rec["safe_daemon"];
+          delete rec["safe_daemon"];
+          for (const [name, c] of this.expandSafeDaemon(cfg)) {
+            if (!(name in rec)) rec[name] = c;
+          }
+        }
+      }
+      if (Array.isArray(n.directives)) {
+        const dirs = n.directives;
+        const idx = dirs.findIndex((d) => d && d.type === "trait" && d.name === "safe_daemon");
+        if (idx >= 0) {
+          const cfg = dirs[idx].config;
+          const expanded = this.expandSafeDaemon(cfg).map(([name, c]) => ({ type: "trait", name, config: c }));
+          const existing = new Set(dirs.map((d) => d.name));
+          dirs.splice(idx, 1, ...expanded.filter((e) => !existing.has(e.name)));
+        }
+      }
+      for (const key of ["children", "body", "states"]) {
+        const child = n[key];
+        if (Array.isArray(child)) child.forEach(visit);
+      }
+    };
+    visit(root);
+  }
   /**
    * Performs an incremental parse using ChunkBasedIncrementalParser with
    * AST-aware chunking, hash-based caching, and dependency tracking.
@@ -2014,28 +2152,48 @@ var HoloScriptPlusParser = class {
         }
         const isNodeStart = this.check("IDENTIFIER") || this.check("STATE_MACHINE") || this.check("STATE") || this.check("TRANSITION") || this.check("INITIAL");
         if (isNodeStart) {
-          const node = this.parseNode();
-          const existingDirectives = node.directives || [];
-          node.directives = [...currentDirectives, ...existingDirectives];
-          if (node.type === "template") {
-            for (const d of currentDirectives) {
-              if (d.type === "version") {
-                node.version = d.version;
-              } else if (d.type === "migrate") {
-                if (!node.migrations) node.migrations = [];
-                node.migrations.push({
-                  type: "Migration",
-                  fromVersion: d.fromVersion,
-                  body: d.body
-                });
+          if (this.check("IDENTIFIER") && this.current().value === "connect") {
+            const connectNode = this.parseHsConnectStatement();
+            topLevelNodes.push(connectNode);
+          } else if (this.check("IDENTIFIER") && this.current().value === "execute") {
+            const executeNode = this.parseHsExecuteStatement();
+            topLevelNodes.push(executeNode);
+          } else if (this.check("IDENTIFIER") && isBrainKeyword(this.current().value)) {
+            const brainNode = this.parseBrainDeclaration();
+            brainNode.directives = [
+              ...currentDirectives,
+              ...brainNode.directives || []
+            ];
+            topLevelNodes.push(brainNode);
+          } else {
+            const node = this.parseNode();
+            const existingDirectives = node.directives || [];
+            node.directives = [...currentDirectives, ...existingDirectives];
+            if (node.type === "template") {
+              for (const d of currentDirectives) {
+                if (d.type === "version") {
+                  node.version = d.version;
+                } else if (d.type === "migrate") {
+                  if (!node.migrations) node.migrations = [];
+                  node.migrations.push({
+                    type: "Migration",
+                    fromVersion: d.fromVersion,
+                    body: d.body
+                  });
+                }
               }
             }
+            topLevelNodes.push(node);
           }
-          topLevelNodes.push(node);
         } else {
           if (currentDirectives.length > 0) {
             if (this.check("EOF")) {
               globalDirectives.push(...currentDirectives);
+            } else if (this.check("LBRACE")) {
+              const block = this.parseBlockContent();
+              const last = currentDirectives[currentDirectives.length - 1];
+              last.config = { ...last.config || {}, ...block };
+              globalDirectives.push(...currentDirectives);
             } else {
               this.error(
                 `Expected node after directives, got ${this.current().type}. Valid nodes: orb, template, logic, object, world, composition, scene, group`,
@@ -2051,21 +2209,6 @@ var HoloScriptPlusParser = class {
             throw new Error("ParseError");
           }
         }
-        if (this.check("IDENTIFIER") && this.current().value === "connect") {
-          const connection = this.parseConnectionStatement();
-          const node = {
-            type: "connection",
-            properties: connection,
-            directives: [],
-            children: [],
-            traits: /* @__PURE__ */ new Map(),
-            loc: {
-              start: { line: this.current().line, column: 0 },
-              end: { line: this.current().line, column: 0 }
-            }
-          };
-          topLevelNodes.push(node);
-        }
       } catch (e) {
         const errorMessage = e instanceof Error ? e.message : String(e);
         if (errorMessage !== "ParseError" && errorMessage !== "Unexpected token") {
@@ -2105,7 +2248,12 @@ var HoloScriptPlusParser = class {
     ]) || this.expect("IDENTIFIER", "Expected element type");
     const type = typeToken.value;
     if (type === "template") {
-      const templateName = this.expect("STRING", "Expected template name").value;
+      let templateName;
+      if (this.check("IDENTIFIER")) {
+        templateName = this.advance().value;
+      } else {
+        templateName = this.expect("STRING", "Expected template name").value;
+      }
       const templateBody = this.parseBlockContent();
       let version;
       const migrations = [];
@@ -2167,6 +2315,20 @@ var HoloScriptPlusParser = class {
         }
       };
     }
+    if (type === "react") {
+      return this.parseHsPlusReactBlock(startToken);
+    }
+    if (["transform", "filter", "branch", "validate"].includes(type)) {
+      const savedPos = this.pos;
+      let blockName = "anonymous";
+      if (this.check("IDENTIFIER") || this.check("STRING")) {
+        blockName = this.advance().value;
+      }
+      if (this.check("LBRACE")) {
+        return this.parsePipelineBlock(type, blockName, startToken);
+      }
+      this.pos = savedPos;
+    }
     if ([
       "module",
       "script",
@@ -2220,6 +2382,9 @@ var HoloScriptPlusParser = class {
     if (type === "assert" || startToken.type === "ASSERT") {
       return this.parseAssertNode();
     }
+    if (type === "timeline") {
+      return this.parseTimelineNode(startToken);
+    }
     if (type === "environment") {
       const envBody = this.parseEnvironmentBlock();
       return {
@@ -2304,6 +2469,7 @@ var HoloScriptPlusParser = class {
     const children = [];
     const directives = [];
     const traits = /* @__PURE__ */ new Map();
+    let ambiguousPreBodyTrait = null;
     if (templateRef) {
       properties.__templateRef = templateRef;
     }
@@ -2323,6 +2489,9 @@ var HoloScriptPlusParser = class {
               traits.set(directive.name, directive.config);
               this.hasVRTraits = true;
               directives.push(directive);
+              if (this.blockConfigDirectives.has(directive) && this.traitConfigLooksLikeNodeBody(directive.config)) {
+                ambiguousPreBodyTrait = directive;
+              }
             } else {
               directives.push(directive);
             }
@@ -2373,6 +2542,13 @@ var HoloScriptPlusParser = class {
         this.synchronizeProperty();
       }
     }
+    if (!this.check("LBRACE") && ambiguousPreBodyTrait) {
+      this.errorAt(
+        this.blockConfigDirectiveLocations.get(ambiguousPreBodyTrait) || startToken,
+        `Trait @${ambiguousPreBodyTrait.name} used a block that looks like an object body, but no object body follows. Use @${ambiguousPreBodyTrait.name}(...) for trait config, or add a separate { ... } object body.`,
+        "HSP101"
+      );
+    }
     if (this.check("LBRACE")) {
       this.advance();
       this.skipNewlines();
@@ -2417,7 +2593,7 @@ var HoloScriptPlusParser = class {
             properties[key] = spreadNode;
           } else {
             const token = this.current();
-            const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "HASH" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
+            const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "HASH" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "ON_ERROR" || token.type === "TRANSITION";
             if (isKeyToken) {
               const saved = this.pos;
               const name = this.advance().value;
@@ -2449,7 +2625,9 @@ var HoloScriptPlusParser = class {
                 "on_entry",
                 "on_exit",
                 "page",
-                "include"
+                "include",
+                "brain",
+                "react"
               ];
               if (name === "transition" && this.check("STRING")) {
                 const event = this.advance().value;
@@ -2528,7 +2706,12 @@ var HoloScriptPlusParser = class {
               }
               if (this.check("COLON") || this.check("EQUALS")) {
                 this.advance();
-                properties[name] = this.parseValue();
+                const pipeNext = this.peek(1);
+                if (this.check("PIPE") && (!pipeNext || pipeNext.type === "NEWLINE" || pipeNext.type === "EOF")) {
+                  properties[name] = this.parseBlockScalar(this.tokens[saved]);
+                } else {
+                  properties[name] = this.parseValue();
+                }
               } else if (childNodeKeywords.includes(name) && (this.check("LBRACE") || this.check("STRING"))) {
                 this.pos = saved;
                 children.push(this.parseNode());
@@ -2585,15 +2768,24 @@ var HoloScriptPlusParser = class {
     const isKeyword = ["STATE_MACHINE", "STATE", "ON_ENTRY", "ON_EXIT", "TRANSITION"].includes(
       nameToken.type
     );
-    if (nameToken.type !== "IDENTIFIER" && !isKeyword) {
+    let name;
+    if (nameToken.type === "IDENTIFIER" || isKeyword) {
+      this.advance();
+      name = nameToken.value;
+    } else if (nameToken.type === "NUMBER" && /^\d+[a-zA-Z]\w*$/.test(nameToken.value)) {
+      this.advance();
+      name = nameToken.value;
+      const next = this.current();
+      if (next.type === "IDENTIFIER" && next.line === nameToken.line && next.column === nameToken.column + nameToken.value.length) {
+        name += this.advance().value;
+      }
+    } else {
       this.error(
         `Expected directive name, got ${nameToken.type}. Directives start with @ followed by name (e.g., @grabbable)`,
         "HSP201"
       );
       return null;
     }
-    this.advance();
-    const name = nameToken.value;
     if (name === "version") {
       this.expect("LPAREN", "Expected ( after @version");
       const versionToken = this.expect("NUMBER", "Expected version number");
@@ -2613,18 +2805,147 @@ var HoloScriptPlusParser = class {
       const body = this.check("LBRACE") ? this.parseCodeBlock() : "";
       return { type: "migrate", fromVersion, body };
     }
+    if (name === "quest") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "quest", ...config2 };
+    }
+    if (name === "faction") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "faction", ...config2 };
+    }
+    if (name === "loot") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "loot", ...config2 };
+    }
+    if (name === "ability") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "ability", ...config2 };
+    }
+    if (name === "authority") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "authority", ...config2 };
+    }
+    if (name === "wallet_gated") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "wallet_gated", ...config2 };
+    }
+    if (name === "world_chunk") {
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+      return { type: "world_chunk", ...config2 };
+    }
+    if (name === "personality") {
+      let value;
+      if (this.check("IDENTIFIER")) {
+        value = this.advance().value;
+      } else if (this.check("STRING")) {
+        value = this.advance().value;
+      } else {
+        value = "neutral";
+      }
+      return { type: "personality", value };
+    }
+    if (name === "faction_alignment") {
+      let value;
+      if (this.check("IDENTIFIER")) {
+        value = this.advance().value;
+        if (this.check("IDENTIFIER")) {
+          value += "_" + this.advance().value;
+        }
+      } else if (this.check("STRING")) {
+        value = this.advance().value;
+      } else {
+        value = "true_neutral";
+      }
+      return { type: "faction_alignment", value };
+    }
+    if (name === "memory_persistence") {
+      let value = true;
+      if (this.check("BOOLEAN")) {
+        value = this.advance().value === "true";
+      } else if (this.check("IDENTIFIER")) {
+        const raw = this.advance().value;
+        value = raw !== "false";
+      }
+      return { type: "memory_persistence", value };
+    }
+    if (name === "preferred_ability") {
+      let abilityName;
+      if (this.check("STRING")) {
+        abilityName = this.advance().value;
+      } else if (this.check("IDENTIFIER")) {
+        abilityName = this.advance().value;
+      } else {
+        abilityName = "";
+      }
+      let when;
+      if (this.check("AT")) {
+        const saved = this.pos;
+        this.advance();
+        if (this.check("IDENTIFIER") && this.current().value === "when") {
+          this.advance();
+          if (this.check("LBRACE")) {
+            when = this.parseCodeBlock();
+          }
+        } else {
+          this.pos = saved;
+        }
+      }
+      return { type: "preferred_ability", ability: abilityName, when };
+    }
+    if (name === "flee_threshold") {
+      let value = 0.25;
+      if (this.check("NUMBER")) {
+        value = parseFloat(this.advance().value);
+      }
+      return { type: "flee_threshold", value };
+    }
+    if (name === "patrol_speed") {
+      let value = 1;
+      if (this.check("NUMBER")) {
+        value = parseFloat(this.advance().value);
+      } else if (this.check("IDENTIFIER")) {
+        value = this.advance().value;
+      }
+      return { type: "patrol_speed", value };
+    }
+    if (name === "waypoints") {
+      let points = [];
+      if (this.check("LBRACKET")) {
+        points = this.parseValue();
+      } else if (this.check("LBRACE")) {
+        points = this.parseBlockContent();
+      }
+      return { type: "waypoints", points };
+    }
     if (VR_TRAITS.includes(name)) {
       if (!this.options.enableVRTraits) {
         this.warn(`VR trait @${name} is disabled`);
         return null;
       }
       let config2 = {};
+      let configStyle2 = "none";
       if (this.check("LPAREN")) {
+        configStyle2 = "paren";
         config2 = this.parseTraitConfig();
       } else if (this.check("LBRACE")) {
+        configStyle2 = "block";
         config2 = this.parseBlockContent();
+      } else if (this.check("COLON")) {
+        configStyle2 = "colon";
+        this.advance();
+        if (this.check("LPAREN")) {
+          config2 = this.parseTraitConfig();
+        } else if (this.check("LBRACE")) {
+          config2 = this.parseBlockContent();
+        } else {
+          config2 = { value: this.parseValue() };
+        }
+      }
+      const directive2 = { type: "trait", name, config: config2 };
+      if (configStyle2 === "block") {
+        this.markBlockConfigDirective(directive2, nameToken);
       }
-      return this.parseTraitSumTail({ type: "trait", name, config: config2 });
+      return this.parseTraitSumTail(directive2);
     }
     if (LIFECYCLE_HOOKS.includes(name)) {
       const params = [];
@@ -2731,15 +3052,22 @@ var HoloScriptPlusParser = class {
           this.warn("Expected 'from' after named import specifiers");
         }
       }
+      let wildcardAlias;
       if (this.check("ASTERISK") || this.check("IDENTIFIER") && this.current().value === "*") {
         this.advance();
         isWildcard = true;
         if (this.check("IDENTIFIER") && this.current().value === "as") {
           this.advance();
+          if (this.check("IDENTIFIER") && this.current().value !== "from") {
+            wildcardAlias = this.advance().value;
+          }
+        }
+        if (this.check("IDENTIFIER") && this.current().value === "from") {
+          this.advance();
         }
       }
       const path = this.expect("STRING", "Expected import path string").value;
-      let alias = path.split("/").pop()?.replace(/\.[^.]+$/, "") || "import";
+      let alias = wildcardAlias || path.split("/").pop()?.replace(/\.[^.]+$/, "") || "import";
       if (!namedImports && this.check("IDENTIFIER") && this.current().value === "as") {
         this.advance();
         alias = this.expect("IDENTIFIER", "Expected alias after as").value;
@@ -2949,9 +3277,12 @@ var HoloScriptPlusParser = class {
       this.warn(`Unknown directive @${name}`);
     }
     let config = {};
+    let configStyle = "none";
     if (this.check("LPAREN")) {
+      configStyle = "paren";
       config = this.parseTraitConfig();
     } else if (this.check("LBRACE")) {
+      configStyle = "block";
       config = this.parseBlockContent();
     }
     if (this.check("COLON")) {
@@ -2962,7 +3293,32 @@ var HoloScriptPlusParser = class {
         config.body = this.parseCodeBlock();
       }
     }
-    return this.parseTraitSumTail({ type: "trait", name, config });
+    const directive = { type: "trait", name, config };
+    if (configStyle === "block") {
+      this.markBlockConfigDirective(directive, nameToken);
+    }
+    return this.parseTraitSumTail(directive);
+  }
+  markBlockConfigDirective(directive, token) {
+    this.blockConfigDirectives.add(directive);
+    this.blockConfigDirectiveLocations.set(directive, token);
+  }
+  traitConfigLooksLikeNodeBody(config) {
+    if (!config || typeof config !== "object") return false;
+    const nodeBodyKeys = /* @__PURE__ */ new Set([
+      "geometry",
+      "position",
+      "rotation",
+      "scale",
+      "size",
+      "color",
+      "material",
+      "model",
+      "mesh",
+      "src",
+      "url"
+    ]);
+    return Object.keys(config).some((key) => nodeBodyKeys.has(key));
   }
   parseTraitSumTail(first) {
     if (!this.check("PLUS")) {
@@ -3001,95 +3357,962 @@ var HoloScriptPlusParser = class {
     this.expect("RPAREN", "Expected )");
     return value;
   }
-  parseConnectionStatement() {
-    this.expect("IDENTIFIER", "Expected connect");
-    const from = this.expect("IDENTIFIER", "Expected from name").value;
-    this.expect("IDENTIFIER", "Expected to");
-    const to = this.expect("IDENTIFIER", "Expected to name").value;
-    return { from, to };
-  }
+  // ===========================================================================
+  // Brain Declaration Parsing
+  // ===========================================================================
   /**
-   * Parse block content: { key: value, ... }
+   * Parse a top-level `brain` declaration.
+   *
+   * Grammar:
+   *   brain <Name> [ : @<brainType> ] {
+   *     @personality <value>
+   *     @faction_alignment <value>
+   *     @memory_persistence true|false
+   *     @preferred_ability "<Name>" [ @when { <expr> } ]
+   *     @flee_threshold <number>
+   *     @patrol_speed <number|identifier>
+   *     @waypoints [...]
+   *     state <stateName> {
+   *       transition to <target> [ @when { <expr> } ]
+   *       <action statements ...>
+   *     }
+   *   }
    */
-  parseBlockContent() {
-    const content = {};
+  parseBrainDeclaration() {
+    this.advance();
+    const name = this.check("IDENTIFIER") ? this.advance().value : "unnamed_brain";
+    let brainType = "behavior_tree";
+    if (this.check("COLON")) {
+      this.advance();
+      if (this.check("AT")) {
+        this.advance();
+        if (this.check("IDENTIFIER")) {
+          const raw = this.advance().value;
+          if (raw === "behavior_tree" || raw === "decision_tree" || raw === "neural" || raw === "scripted") {
+            brainType = raw;
+          }
+        }
+      }
+    }
+    const brain = {
+      type: "brain",
+      name,
+      brainType,
+      states: [],
+      traits: {}
+    };
     if (!this.check("LBRACE")) {
-      return content;
+      this.warn(`brain "${name}" missing body block { }`);
+      return brain;
     }
     this.advance();
     this.skipNewlines();
     while (!this.check("RBRACE") && !this.check("EOF")) {
       this.skipNewlines();
       if (this.check("RBRACE") || this.check("EOF")) break;
-      this.skipNewlines();
-      if (this.check("RBRACE") || this.check("EOF")) break;
-      const token = this.current();
-      const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
-      if (isKeyToken) {
-        const next = this.peek(1);
-        if (next.type === "COLON" || next.type === "EQUALS") {
-          const key = this.advance().value;
-          this.advance();
-          content[key] = this.parseValue();
-        } else if (next.type === "STRING" || next.type === "LBRACE" || next.type === "IDENTIFIER") {
-          const node = this.parseNode();
-          const type = node.type;
-          const name = node.name || `unnamed_${type}_${Object.keys(content).length}`;
-          content[name] = node;
-        } else {
-          const key = this.advance().value;
-          content[key] = true;
-        }
-      } else if (this.check("SPREAD")) {
+      if (this.check("AT")) {
         this.advance();
-        const val = this.parseValue();
-        const spreadKey = `__spread_${Object.keys(content).length}`;
-        content[spreadKey] = { type: "spread", argument: val };
-      } else if (this.check("AT")) {
-        const directive = this.parseDirective();
-        if (directive) {
-          const dirKey = ("name" in directive ? directive.name : void 0) || directive.type;
-          content[`@${dirKey}`] = directive;
+        if (!this.check("IDENTIFIER")) {
+          this.warn("Expected directive name after @");
+          continue;
         }
-      } else if (this.check("LBRACE")) {
-        let depth = 1;
+        const dirName = this.advance().value;
+        if (dirName === "personality") {
+          const val = this.check("IDENTIFIER") ? this.advance().value : this.check("STRING") ? this.advance().value : "neutral";
+          brain.personality = val;
+        } else if (dirName === "faction_alignment") {
+          let val = this.check("IDENTIFIER") ? this.advance().value : this.check("STRING") ? this.advance().value : "true_neutral";
+          if (this.check("IDENTIFIER")) val += "_" + this.advance().value;
+          brain.factionAlignment = val;
+        } else if (dirName === "memory_persistence") {
+          const raw = this.check("BOOLEAN") ? this.advance().value : this.check("IDENTIFIER") ? this.advance().value : "true";
+          brain.memoryPersistence = raw !== "false";
+        } else if (dirName === "preferred_ability") {
+          const abilityName = this.check("STRING") ? this.advance().value : this.check("IDENTIFIER") ? this.advance().value : "";
+          let when;
+          if (this.check("AT")) {
+            const saved = this.pos;
+            this.advance();
+            if (this.check("IDENTIFIER") && this.current().value === "when") {
+              this.advance();
+              if (this.check("LBRACE")) when = this.parseCodeBlock();
+            } else {
+              this.pos = saved;
+            }
+          }
+          brain.preferredAbility = { name: abilityName, when };
+        } else if (dirName === "flee_threshold") {
+          brain.fleeThreshold = this.check("NUMBER") ? parseFloat(this.advance().value) : 0.25;
+        } else if (dirName === "patrol_speed") {
+          brain.patrolSpeed = this.check("NUMBER") ? parseFloat(this.advance().value) : this.check("IDENTIFIER") ? this.advance().value : 1;
+        } else if (dirName === "waypoints") {
+          brain.waypoints = this.check("LBRACKET") ? this.parseValue() : [];
+        } else if (dirName === "goal") {
+          const cfg = this.check("LBRACE") ? this.parseBlockContent() : {};
+          if (!brain.goals) brain.goals = [];
+          brain.goals.push({
+            name: typeof cfg.name === "string" ? cfg.name : String(cfg.name ?? `goal_${brain.goals.length}`),
+            desiredState: cfg.desiredState && typeof cfg.desiredState === "object" ? cfg.desiredState : void 0,
+            priority: typeof cfg.priority === "number" ? cfg.priority : void 0
+          });
+        } else if (dirName === "escalation") {
+          const cfg = this.check("LBRACE") ? this.parseBlockContent() : {};
+          if (!brain.escalations) brain.escalations = [];
+          brain.escalations.push({
+            on: typeof cfg.on === "string" ? cfg.on : String(cfg.on ?? ""),
+            action: typeof cfg.action === "string" ? cfg.action : "notify"
+          });
+        } else if (dirName === "provider_policy") {
+          const cfg = this.check("LBRACE") ? this.parseBlockContent() : {};
+          brain.providerPolicy = {
+            prefer: typeof cfg.prefer === "string" ? cfg.prefer : void 0,
+            fallback: typeof cfg.fallback === "string" ? cfg.fallback : void 0,
+            requires: typeof cfg.requires === "string" ? cfg.requires : void 0
+          };
+        } else if (dirName === "frame_declaration") {
+          const cfg = this.check("LBRACE") ? this.parseBlockContent() : {};
+          brain.frameDeclaration = coerceConfig(cfg);
+        } else if (dirName === "behavior_tree") {
+          const config = this.check("LBRACE") ? this.parseBlockContent() : {};
+          brain.traits["behavior_tree"] = config;
+        } else {
+          const config = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+          brain.traits[dirName] = config;
+        }
+        this.skipNewlines();
+        continue;
+      }
+      if (this.check("STATE") || this.check("IDENTIFIER") && this.current().value === "state") {
         this.advance();
-        while (depth > 0 && !this.check("EOF")) {
-          if (this.check("LBRACE")) depth++;
-          if (this.check("RBRACE")) depth--;
+        const stateName = this.check("IDENTIFIER") ? this.advance().value : "unnamed";
+        const brainState = {
+          name: stateName,
+          transitions: [],
+          actions: [],
+          traits: {}
+        };
+        if (this.check("LBRACE")) {
           this.advance();
+          this.skipNewlines();
+          while (!this.check("RBRACE") && !this.check("EOF")) {
+            this.skipNewlines();
+            if (this.check("RBRACE") || this.check("EOF")) break;
+            if (this.check("TRANSITION") || this.check("IDENTIFIER") && this.current().value === "transition") {
+              this.advance();
+              let to = "";
+              if (this.check("IDENTIFIER") && this.current().value === "to") {
+                this.advance();
+              }
+              if (this.check("IDENTIFIER")) to = this.advance().value;
+              else if (this.check("STRING")) to = this.advance().value;
+              let when;
+              if (this.check("AT")) {
+                const saved = this.pos;
+                this.advance();
+                if (this.check("IDENTIFIER") && this.current().value === "when") {
+                  this.advance();
+                  if (this.check("LBRACE")) when = this.parseCodeBlock();
+                } else {
+                  this.pos = saved;
+                }
+              }
+              brainState.transitions.push({ to, when });
+            } else if (this.check("AT")) {
+              this.advance();
+              const innerDir = this.check("IDENTIFIER") ? this.advance().value : "";
+              const config = this.check("LBRACE") ? this.parseBlockContent() : this.check("LPAREN") ? this.parseTraitConfig() : {};
+              brainState.traits[innerDir] = config;
+            } else if (this.check("IDENTIFIER") && isCognitiveVerb(this.current().value)) {
+              const saved = this.pos;
+              const verb = this.advance().value;
+              if (this.check("LBRACE")) {
+                const config = this.parseBlockContent();
+                if (!brainState.cognitiveActions) brainState.cognitiveActions = [];
+                brainState.cognitiveActions.push({ kind: "cognitive", verb, config });
+              } else {
+                this.pos = saved;
+                const parts = [this.advance().value];
+                while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+                  parts.push(this.advance().value);
+                }
+                brainState.actions.push(parts.join(" "));
+              }
+            } else if (this.check("IDENTIFIER") && this.tokens[this.pos + 1]?.type === "LBRACE" && nearestCognitiveVerb(this.current().value)) {
+              const typo = this.current().value;
+              const suggestion = nearestCognitiveVerb(typo);
+              this.warn(`Unknown cognitive verb '${typo}' \u2014 did you mean '${suggestion}'?`);
+              this.advance();
+              this.parseBlockContent();
+              brainState.actions.push(typo);
+            } else if (this.check("IDENTIFIER")) {
+              const parts = [this.advance().value];
+              while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+                parts.push(this.advance().value);
+              }
+              brainState.actions.push(parts.join(" "));
+            } else {
+              this.advance();
+            }
+            this.skipNewlines();
+          }
+          this.expect("RBRACE", "Expected } to close state block");
         }
-      } else if (this.check("LPAREN")) {
-        this.skipParens();
+        brain.states.push(brainState);
+        this.skipNewlines();
+        continue;
+      }
+      if (this.check("IDENTIFIER")) {
+        const parts = [this.advance().value];
+        while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+          parts.push(this.advance().value);
+        }
+        brain.traits["_actions"] = [
+          ...brain.traits["_actions"] || [],
+          parts.join(" ")
+        ];
       } else {
         this.advance();
       }
-      if (this.check("COMMA")) this.advance();
       this.skipNewlines();
     }
-    this.expect("RBRACE", "Expected }");
-    return content;
+    this.expect("RBRACE", "Expected } to close brain declaration");
+    return brain;
   }
   /**
-   * Parse bindings block: { bind(expr) -> target, ... }
+   * Parse a .hs `connect` statement.
+   * Syntax (full .hs format):
+   *   connect <source> -> <target>
+   * where <source> and <target> are dotted member chains, optionally followed
+   * by assignment for state connections:
+   *   connect alarm_bell.alarm_triggered -> guard_captain.state.alert_level = 3
+   *
+   * Strategy: consume the `connect` keyword, then collect all tokens up to
+   * (but not including) the next NEWLINE / EOF as a raw string.  This is
+   * intentionally permissive — the connect statement has a rich surface syntax
+   * (dotted paths, ARROW, assignments) that the generic property parser cannot
+   * handle.  Semantic validation of the wiring is a separate compilation phase.
    */
-  parseBindingsBlock() {
-    const bindings = [];
-    if (!this.check("LBRACE")) {
-      return bindings;
+  parseHsConnectStatement() {
+    const startToken = this.current();
+    this.advance();
+    const toks = [];
+    while (!this.check("NEWLINE") && !this.check("EOF")) {
+      toks.push(this.advance());
     }
+    const arrowIdx = toks.findIndex((t) => t.type === "ARROW");
+    const fromToks = arrowIdx >= 0 ? toks.slice(0, arrowIdx) : toks;
+    const toToks = arrowIdx >= 0 ? toks.slice(arrowIdx + 1) : [];
+    return {
+      type: "connection",
+      properties: {
+        from: this.joinTokensSmart(fromToks),
+        to: this.joinTokensSmart(toToks),
+        raw: this.joinTokensSmart(toks)
+      },
+      directives: [],
+      children: [],
+      traits: /* @__PURE__ */ new Map(),
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  /**
+   * Parse a .hs `execute` statement.
+   * Syntax:
+   *   execute <target>(<args>) [repeat forever | every <interval>]
+   * Examples:
+   *   execute guard_captain.patrol() repeat forever
+   *   execute temp_sensor_A.read() every 1000ms
+   *
+   * Strategy: consume `execute` then collect all tokens to end of line.
+   * The target is the leading member chain plus one balanced call-paren
+   * group; everything after it is the schedule clause.
+   */
+  parseHsExecuteStatement() {
+    const startToken = this.current();
     this.advance();
-    this.skipNewlines();
-    while (!this.check("RBRACE") && !this.check("EOF")) {
-      this.skipNewlines();
-      if (this.check("RBRACE") || this.check("EOF")) break;
-      if (this.check("IDENTIFIER") && this.current().value === "bind") {
-        this.advance();
-        if (this.check("LPAREN")) {
-          this.advance();
-          let source = "";
-          let parenDepth = 1;
-          while (parenDepth > 0 && !this.check("EOF")) {
+    const toks = [];
+    while (!this.check("NEWLINE") && !this.check("EOF")) {
+      toks.push(this.advance());
+    }
+    let end = toks.length;
+    let depth = 0;
+    for (let i = 0; i < toks.length; i++) {
+      const t = toks[i];
+      if (t.type === "LPAREN") {
+        depth++;
+      } else if (t.type === "RPAREN") {
+        depth--;
+        if (depth === 0) {
+          end = i + 1;
+          break;
+        }
+      } else if (depth === 0 && t.type !== "IDENTIFIER" && t.type !== "DOT" && t.type !== "NUMBER") {
+        end = i;
+        break;
+      }
+    }
+    const target = this.joinTokensSmart(toks.slice(0, end));
+    const schedule = this.joinTokensSmart(toks.slice(end));
+    return {
+      type: "execute",
+      properties: { target, schedule, raw: this.joinTokensSmart(toks) },
+      directives: [],
+      children: [],
+      traits: /* @__PURE__ */ new Map(),
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  // ===========================================================================
+  // Pipeline DSL block parsing (transform / filter / branch / validate)
+  // ===========================================================================
+  /**
+   * Reassemble token values into readable source text: no spaces around
+   * member/call/index punctuation, string literals re-quoted.
+   */
+  joinTokensSmart(tokens) {
+    const NO_SPACE_BEFORE = /* @__PURE__ */ new Set([
+      "DOT",
+      "COMMA",
+      "LPAREN",
+      "RPAREN",
+      "LBRACKET",
+      "RBRACKET",
+      "OPTIONAL_DOT"
+    ]);
+    const NO_SPACE_AFTER = /* @__PURE__ */ new Set(["DOT", "LPAREN", "LBRACKET", "OPTIONAL_DOT", "EXCLAMATION"]);
+    let out = "";
+    let prev = null;
+    for (const t of tokens) {
+      const text = t.type === "STRING" ? JSON.stringify(t.value) : t.value;
+      if (prev && !NO_SPACE_BEFORE.has(t.type) && !NO_SPACE_AFTER.has(prev.type)) {
+        out += " ";
+      }
+      out += text;
+      prev = t;
+    }
+    return out;
+  }
+  /** Capture a dotted/indexed path: sku, a.b.c, results[0].id, entries[] */
+  capturePipelinePath() {
+    const toks = [];
+    if (this.check("IDENTIFIER") || this.check("STRING") || this.check("UNDERSCORE")) {
+      toks.push(this.advance());
+    }
+    for (; ; ) {
+      if (this.check("DOT")) {
+        toks.push(this.advance());
+        if (this.check("IDENTIFIER") || this.check("NUMBER") || this.check("UNDERSCORE")) {
+          toks.push(this.advance());
+        }
+        continue;
+      }
+      if (this.check("LBRACKET")) {
+        let depth = 0;
+        do {
+          const t = this.advance();
+          toks.push(t);
+          if (t.type === "LBRACKET") depth++;
+          else if (t.type === "RBRACKET") depth--;
+        } while (depth > 0 && !this.check("EOF"));
+        continue;
+      }
+      break;
+    }
+    return { raw: this.joinTokensSmart(toks), tokens: toks };
+  }
+  /** Capture a transform op call: trim() / multiply(100) / increment_if(a == b.c) */
+  capturePipelineOp() {
+    const toks = [];
+    if (this.check("IDENTIFIER")) {
+      toks.push(this.advance());
+    }
+    if (this.check("LPAREN")) {
+      let depth = 0;
+      do {
+        const t = this.advance();
+        toks.push(t);
+        if (t.type === "LPAREN") depth++;
+        else if (t.type === "RPAREN") depth--;
+      } while (depth > 0 && !this.check("EOF"));
+    }
+    return this.joinTokensSmart(toks);
+  }
+  /** True when an ARROW appears before the end of the current statement line. */
+  hasArrowBeforeEOL() {
+    for (let look = this.pos; look < this.tokens.length; look++) {
+      const t = this.tokens[look].type;
+      if (t === "ARROW") return true;
+      if (t === "NEWLINE" || t === "EOF" || t === "RBRACE" || t === "LBRACE") return false;
+    }
+    return false;
+  }
+  /**
+   * Capture expression tokens to end of line, honoring `||` / `&&`
+   * line continuations:
+   *   where: stock != previous.stock
+   *       || costCents != previous.costCents
+   */
+  captureExpressionToEOL() {
+    const toks = [];
+    for (; ; ) {
+      while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+        toks.push(this.advance());
+      }
+      if (this.check("NEWLINE")) {
+        let look = this.pos;
+        while (look < this.tokens.length && ["NEWLINE", "INDENT", "DEDENT"].includes(this.tokens[look].type)) {
+          look++;
+        }
+        const next = this.tokens[look];
+        if (next && (next.type === "OR" || next.type === "AND")) {
+          this.pos = look;
+          continue;
+        }
+      }
+      break;
+    }
+    return toks;
+  }
+  /**
+   * YAML-style block scalar property value:
+   *   prompt: |
+   *     Extract wisdom from this content.
+   *     Return JSON.
+   * Captures the following lines from raw source while they are blank or
+   * indented deeper than the key line, dedents, and skips their tokens.
+   */
+  parseBlockScalar(keyToken) {
+    this.advance();
+    const keyIndent = keyToken.column - 1;
+    const lines = this.source.split("\n");
+    const collected = [];
+    let lastLine = keyToken.line;
+    for (let ln = keyToken.line + 1; ln <= lines.length; ln++) {
+      const text = lines[ln - 1];
+      if (text.trim() === "") {
+        collected.push("");
+        lastLine = ln;
+        continue;
+      }
+      const indent = text.length - text.trimStart().length;
+      if (indent <= keyIndent) break;
+      collected.push(text);
+      lastLine = ln;
+    }
+    while (!this.check("EOF") && this.current().line <= lastLine) {
+      this.advance();
+    }
+    const nonBlank = collected.filter((l) => l.trim() !== "");
+    const minIndent = nonBlank.length ? Math.min(...nonBlank.map((l) => l.length - l.trimStart().length)) : 0;
+    return collected.map((l) => l.slice(minIndent)).join("\n").replace(/\s+$/, "");
+  }
+  /** Property value inside a pipeline DSL block. */
+  parsePipelinePropertyValue(keyToken) {
+    if (this.check("PIPE")) {
+      const next = this.peek(1);
+      if (!next || next.type === "NEWLINE" || next.type === "EOF") {
+        return this.parseBlockScalar(keyToken);
+      }
+    }
+    if (this.check("LBRACE") || this.check("LBRACKET")) {
+      return this.parseValue();
+    }
+    const toks = this.captureExpressionToEOL();
+    if (toks.length === 1) {
+      const t = toks[0];
+      if (t.type === "STRING") return t.value;
+      if (t.type === "NUMBER") {
+        const n = Number(t.value);
+        return Number.isNaN(n) ? t.value : n;
+      }
+      if (t.value === "true") return true;
+      if (t.value === "false") return false;
+      return t.value;
+    }
+    return this.joinTokensSmart(toks);
+  }
+  /**
+   * Body parser for pipeline DSL blocks. Handles, per statement:
+   *   key: value                                  → property (incl. block scalars)
+   *   src.path[0] -> dst.path : op() : op2(...)   → mapping child
+   *   when <cond> -> <target>                     → when child (branch)
+   *   default -> <target>                         → default child (branch)
+   *   field.path : rule, rule(...)                → constraint child (validate /
+   *                                                 dotted fields anywhere)
+   * Statements are captured structurally with their raw text preserved;
+   * semantic validation of the wiring is a separate compilation phase.
+   */
+  parsePipelineBlock(kind, name, startToken) {
+    this.expect("LBRACE", `Expected { after ${kind} ${name}`);
+    const properties = {};
+    const children = [];
+    const directives = [];
+    const traits = /* @__PURE__ */ new Map();
+    const childLoc = (tok) => ({
+      start: { line: tok.line, column: tok.column },
+      end: { line: this.current().line, column: this.current().column }
+    });
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      try {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("EOF")) break;
+        if (this.check("AT")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            if (directive.type === "trait") {
+              traits.set(directive.name, directive.config);
+              this.hasVRTraits = true;
+            }
+            directives.push(directive);
+          }
+        } else if (kind === "branch" && this.check("IDENTIFIER") && this.current().value === "when") {
+          const stmtStart = this.advance();
+          const condToks = [];
+          while (!this.check("ARROW") && !this.check("NEWLINE") && !this.check("EOF")) {
+            condToks.push(this.advance());
+          }
+          let target = "";
+          if (this.check("ARROW")) {
+            this.advance();
+            const targetToks = [];
+            while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+              targetToks.push(this.advance());
+            }
+            target = this.joinTokensSmart(targetToks);
+          }
+          children.push({
+            type: "when",
+            condition: this.joinTokensSmart(condToks),
+            target,
+            loc: childLoc(stmtStart)
+          });
+        } else if (this.hasArrowBeforeEOL()) {
+          const stmtStart = this.current();
+          const lhsToks = [];
+          while (!this.check("ARROW") && !this.check("NEWLINE") && !this.check("EOF")) {
+            lhsToks.push(this.advance());
+          }
+          if (this.check("ARROW")) this.advance();
+          const from = this.joinTokensSmart(lhsToks);
+          if (kind === "branch") {
+            const targetToks = [];
+            while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+              targetToks.push(this.advance());
+            }
+            children.push({
+              type: from === "default" ? "default" : "route",
+              from,
+              target: this.joinTokensSmart(targetToks),
+              loc: childLoc(stmtStart)
+            });
+          } else {
+            const to = this.capturePipelinePath();
+            const ops = [];
+            while (this.check("COLON")) {
+              this.advance();
+              ops.push(this.capturePipelineOp());
+            }
+            children.push({
+              type: "mapping",
+              from,
+              to: to.raw,
+              ops,
+              loc: childLoc(stmtStart)
+            });
+          }
+        } else if (this.check("IDENTIFIER") || this.check("STRING")) {
+          const keyToken = this.current();
+          const path = this.capturePipelinePath();
+          if (this.check("COLON")) {
+            this.advance();
+            const pathIsDotted = path.tokens.some((t) => t.type === "DOT" || t.type === "LBRACKET");
+            if (kind === "validate" || pathIsDotted) {
+              const ruleToks = this.captureExpressionToEOL();
+              children.push({
+                type: "constraint",
+                field: path.raw,
+                rules: this.joinTokensSmart(ruleToks),
+                loc: childLoc(keyToken)
+              });
+            } else {
+              properties[path.raw] = this.parsePipelinePropertyValue(keyToken);
+            }
+          } else {
+            properties[path.raw] = true;
+          }
+        } else if (this.check("COMMA")) {
+          this.advance();
+        } else {
+          this.error(
+            `Unexpected token ${this.current().type} "${this.current().value}" in ${kind} block`,
+            "HSP001"
+          );
+          this.synchronizeProperty();
+        }
+        this.skipNewlines();
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        if (errorMessage !== "ParseError") console.error(e);
+        this.synchronizeProperty();
+      }
+    }
+    this.expect("RBRACE", "Expected }");
+    return {
+      type: kind,
+      name,
+      id: name,
+      properties,
+      directives,
+      children,
+      traits,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  /** @deprecated Use parseHsConnectStatement for .hs connect syntax */
+  parseConnectionStatement() {
+    this.expect("IDENTIFIER", "Expected connect");
+    const from = this.expect("IDENTIFIER", "Expected from name").value;
+    this.expect("IDENTIFIER", "Expected to");
+    const to = this.expect("IDENTIFIER", "Expected to name").value;
+    return { from, to };
+  }
+  /**
+   * Map a reaction trigger to its routing bucket (mirrors the .hs parser's
+   * reactionCategory; the movement-trigger list comes from the locomotion SSOT).
+   */
+  hsplusReactionCategory(trigger) {
+    if (isLocomotionReactionTrigger(trigger)) return "movement";
+    switch (trigger) {
+      case "on_interact":
+      case "on_grab":
+      case "on_release":
+      case "on_use":
+      case "on_hover":
+        return "interaction";
+      case "on_collision":
+      case "on_collide":
+      case "on_proximity":
+        return "collision";
+      case "on_spawn":
+      case "on_death":
+      case "on_enter":
+      case "on_exit":
+      case "on_tick":
+        return "lifecycle";
+      case "on_combat":
+      case "on_cast":
+        return "combat";
+      case "on_signal":
+      case "on_input":
+        return "signal";
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Parse a declarative reaction block attached to an entity:
+   *   react {
+   *     on_grab(hand) => highlight()
+   *     on_proximity(player) => alert(player)
+   *     on_use => { open(); play_sound("creak") }
+   *   }
+   * A leading `on` word is optional (`on collide(...)` == `on_collide(...)`).
+   * Each entry becomes a `reaction` child node carrying trigger/params/body and
+   * an inferred ReactionCategory. Body is captured raw (an expression or block).
+   */
+  parseHsPlusReactBlock(startToken) {
+    const startLoc = { line: startToken.line, column: startToken.column };
+    const reactions = [];
+    this.skipNewlines();
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("EOF")) break;
+        let triggerPrefix = "";
+        if (this.check("IDENTIFIER") && this.current().value === "on" && this.tokens[this.pos + 1]?.type === "IDENTIFIER") {
+          this.advance();
+          triggerPrefix = "on_";
+        }
+        if (!this.check("IDENTIFIER")) {
+          this.advance();
+          continue;
+        }
+        const trigger = triggerPrefix + this.advance().value;
+        const params = [];
+        if (this.check("LPAREN")) {
+          this.advance();
+          while (!this.check("RPAREN") && !this.check("EOF")) {
+            if (this.check("IDENTIFIER")) params.push(this.advance().value);
+            else this.advance();
+            if (this.check("COMMA")) this.advance();
+          }
+          if (this.check("RPAREN")) this.advance();
+        }
+        if (this.check("ARROW")) this.advance();
+        let body = "";
+        if (this.check("LBRACE")) {
+          body = this.parseRawBlock();
+        } else {
+          const parts = [];
+          while (!this.check("NEWLINE") && !this.check("EOF") && !this.check("RBRACE")) {
+            parts.push(this.advance().value);
+          }
+          body = parts.join(" ").trim();
+        }
+        reactions.push({
+          type: "reaction",
+          name: trigger,
+          event: trigger,
+          body,
+          properties: {
+            trigger,
+            params,
+            category: this.hsplusReactionCategory(trigger)
+          }
+        });
+        this.skipNewlines();
+      }
+      if (this.check("RBRACE")) this.advance();
+    }
+    return {
+      type: "react-block",
+      name: "react",
+      children: reactions,
+      properties: { count: reactions.length },
+      directives: [],
+      traits: /* @__PURE__ */ new Map(),
+      loc: {
+        start: startLoc,
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  /**
+   * Parse a `timeline <name> { …properties, track-blocks, children }` node.
+   * (Theatre.js harvest S1.) Produces the same shape as the canonical Rust
+   * grammar: a `timeline` node whose `children` include structured `track`
+   * nodes (`{ type: 'track', target, keyframes: [...] }`). Non-track lines are
+   * handled the generic way: `key: value` → property, nested block keyword →
+   * child node. The `timeline` keyword has already been consumed by the caller.
+   */
+  parseTimelineNode(startToken) {
+    let name;
+    if (this.check("STRING") || this.check("IDENTIFIER")) {
+      name = this.advance().value;
+    }
+    const properties = {};
+    const children = [];
+    const directives = [];
+    const traits = /* @__PURE__ */ new Map();
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("EOF")) break;
+        if (this.check("AT")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            if (directive.type === "trait") {
+              traits.set(directive.name, directive.config);
+              this.hasVRTraits = true;
+            }
+            directives.push(directive);
+          }
+          this.skipNewlines();
+          continue;
+        }
+        const token = this.current();
+        const next = this.peek(1);
+        if (token.type === "IDENTIFIER" && token.value === "track" && (next.type === "STRING" || next.type === "IDENTIFIER") && this.peek(2).type === "LBRACE") {
+          this.advance();
+          children.push(this.parseTrackNode(token));
+          if (this.check("COMMA")) this.advance();
+          this.skipNewlines();
+          continue;
+        }
+        if ((token.type === "IDENTIFIER" || token.type === "STRING") && (next.type === "COLON" || next.type === "EQUALS")) {
+          const key = this.advance().value;
+          this.advance();
+          properties[key] = this.parseValue();
+          if (this.check("COMMA")) this.advance();
+          this.skipNewlines();
+          continue;
+        }
+        if (token.type === "IDENTIFIER" || token.type === "STRING") {
+          children.push(this.parseNode());
+          if (this.check("COMMA")) this.advance();
+          this.skipNewlines();
+          continue;
+        }
+        this.advance();
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected } to close timeline block");
+    }
+    return {
+      type: "timeline",
+      name,
+      id: name,
+      properties,
+      directives,
+      children,
+      traits,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  /**
+   * Parse a keyframe-track inside a timeline:
+   *   track "<target>" { key <time> { <value> } [easing <ease>] ; … }
+   * Mirrors the Rust `TrackNode`/`KeyframeNode`. `;` is skipped by the lexer,
+   * so keyframe separators are implicit. The `track` keyword has already been
+   * consumed by the caller. Returns `{ type: 'track', target, keyframes }`.
+   */
+  parseTrackNode(startToken) {
+    const target = this.check("STRING") ? this.advance().value : this.expect("IDENTIFIER", "Expected track target name").value;
+    const keyframes = [];
+    this.expect("LBRACE", "Expected { to open track block");
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("COMMA")) {
+        this.advance();
+        continue;
+      }
+      if (this.check("IDENTIFIER") && this.current().value === "key") {
+        this.advance();
+        let timeSign = 1;
+        if (this.check("MINUS")) {
+          this.advance();
+          timeSign = -1;
+        }
+        const timeTok = this.expect("NUMBER", "Expected numeric time after key");
+        const time = timeSign * Number(timeTok.value);
+        this.expect("LBRACE", "Expected { value block after key time");
+        const value = this.parseValue();
+        this.expect("RBRACE", "Expected } to close key value block");
+        let easing;
+        if (this.check("IDENTIFIER") && this.current().value === "easing") {
+          this.advance();
+          if (this.check("IDENTIFIER") || this.check("STRING")) {
+            easing = this.advance().value;
+          }
+        }
+        keyframes.push(easing === void 0 ? { time, value } : { time, value, easing });
+        this.skipNewlines();
+        continue;
+      }
+      this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected } to close track block");
+    return {
+      type: "track",
+      target,
+      keyframes,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  /**
+   * Parse block content: { key: value, ... }
+   */
+  parseBlockContent() {
+    const content = {};
+    if (!this.check("LBRACE")) {
+      return content;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      const token = this.current();
+      const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
+      if (isKeyToken) {
+        const next = this.peek(1);
+        if (next.type === "COLON" || next.type === "EQUALS") {
+          const key = this.advance().value;
+          this.advance();
+          content[key] = this.parseValue();
+        } else if (next.type === "STRING" || next.type === "LBRACE" || next.type === "IDENTIFIER") {
+          const node = this.parseNode();
+          const type = node.type;
+          const name = node.name || `unnamed_${type}_${Object.keys(content).length}`;
+          content[name] = node;
+        } else {
+          const key = this.advance().value;
+          content[key] = true;
+        }
+      } else if (this.check("SPREAD")) {
+        this.advance();
+        const val = this.parseValue();
+        const spreadKey = `__spread_${Object.keys(content).length}`;
+        content[spreadKey] = { type: "spread", argument: val };
+      } else if (this.check("AT")) {
+        const directive = this.parseDirective();
+        if (directive) {
+          const dirKey = ("name" in directive ? directive.name : void 0) || directive.type;
+          content[`@${dirKey}`] = directive;
+        }
+      } else if (this.check("LBRACE")) {
+        let depth = 1;
+        this.advance();
+        while (depth > 0 && !this.check("EOF")) {
+          if (this.check("LBRACE")) depth++;
+          if (this.check("RBRACE")) depth--;
+          this.advance();
+        }
+      } else if (this.check("LPAREN")) {
+        this.skipParens();
+      } else {
+        this.advance();
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return content;
+  }
+  /**
+   * Parse bindings block: { bind(expr) -> target, ... }
+   */
+  parseBindingsBlock() {
+    const bindings = [];
+    if (!this.check("LBRACE")) {
+      return bindings;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "bind") {
+        this.advance();
+        if (this.check("LPAREN")) {
+          this.advance();
+          let source = "";
+          let parenDepth = 1;
+          while (parenDepth > 0 && !this.check("EOF")) {
             if (this.check("LPAREN")) parenDepth++;
             if (this.check("RPAREN")) {
               parenDepth--;
@@ -3194,7 +4417,8 @@ var HoloScriptPlusParser = class {
       "camera",
       "timeline",
       "page",
-      "include"
+      "include",
+      "react"
     ];
     while (!this.check("RBRACE") && !this.check("EOF")) {
       const currentDirectives = [];
@@ -3713,7 +4937,9 @@ var HoloScriptPlusParser = class {
     if (startToken.type === "STATE_MACHINE") {
       this.advance();
     }
-    const name = this.expect("IDENTIFIER", "Expected state machine name").value;
+    const name = this.parseStateMachineIdentifier("Expected state machine name");
+    const inputs = [];
+    const listeners = [];
     const states = [];
     const transitions = [];
     let initialState = "";
@@ -3726,7 +4952,13 @@ var HoloScriptPlusParser = class {
       if (current.type === "INITIAL" || current.value === "initial") {
         this.advance();
         this.expect("COLON", "Expected : after initial");
-        initialState = this.expect("STRING", "Expected initial state name").value;
+        initialState = this.parseStateMachineIdentifier("Expected initial state name");
+      } else if (current.value === "input") {
+        inputs.push(this.parseStateMachineInputDeclaration());
+      } else if (current.value === "listen") {
+        listeners.push(this.parseStateMachineListenerDeclaration());
+      } else if (this.isStateMachineTransitionShorthandStart()) {
+        transitions.push(this.parseStateMachineTransitionShorthand());
       } else if (current.type === "STATE" || current.value === "state") {
         states.push(this.parseStateNode());
       } else if (current.type === "TRANSITION" || current.value === "transitions") {
@@ -3741,6 +4973,8 @@ var HoloScriptPlusParser = class {
       type: "state-machine",
       name,
       initialState,
+      inputs,
+      listeners,
       states,
       transitions,
       loc: {
@@ -3751,9 +4985,10 @@ var HoloScriptPlusParser = class {
   }
   parseStateNode() {
     this.advance();
-    const name = this.expect("IDENTIFIER", "Expected state name").value;
+    const name = this.parseStateMachineIdentifier("Expected state name");
     let onEntry;
     let onExit;
+    const metadata = {};
     this.expect("LBRACE", "Expected { after state name");
     this.skipNewlines();
     while (!this.check("RBRACE") && !this.check("EOF")) {
@@ -3766,19 +5001,39 @@ var HoloScriptPlusParser = class {
       } else if (current.type === "ON_EXIT" || current.value === "on_exit") {
         this.advance();
         onExit = this.parseCodeBlock();
+      } else if (this.isStateMachineStateMetadataKey(current.value) && this.peek(1).type === "COLON") {
+        const key = this.advance().value;
+        this.expect("COLON", `Expected : after ${key}`);
+        metadata[key] = this.parseValue();
       } else {
         this.advance();
       }
       this.skipNewlines();
     }
     this.expect("RBRACE", "Expected }");
-    return { name, onEntry, onExit };
+    return { name, onEntry, onExit, ...metadata };
+  }
+  isStateMachineStateMetadataKey(key) {
+    return key === "clip" || key === "clips" || key === "parameter" || key === "parameters" || key === "thresholds" || key === "blendType" || key === "blend_type" || key === "blend" || key === "blendMode" || key === "blend_mode" || key === "mask" || key === "baseline";
   }
   parseOnErrorNode() {
     const startToken = this.previous();
+    const params = [];
+    if (this.check("LPAREN")) {
+      this.advance();
+      while (!this.check("RPAREN") && !this.check("EOF") && !this.check("LBRACE")) {
+        if (this.check("IDENTIFIER")) {
+          params.push(this.advance().value);
+        } else {
+          this.advance();
+        }
+      }
+      if (this.check("RPAREN")) this.advance();
+    }
     const body = this.parseControlFlowBody();
     return {
       type: "on_error",
+      params,
       body,
       loc: {
         start: { line: startToken.line, column: startToken.column },
@@ -3813,17 +5068,153 @@ var HoloScriptPlusParser = class {
     while (!this.check("RBRACE") && !this.check("EOF")) {
       this.skipNewlines();
       if (this.check("RBRACE") || this.check("EOF")) break;
-      const from = this.expect("IDENTIFIER", "Expected source state").value;
-      this.expect("ARROW", "Expected ->");
-      const to = this.expect("IDENTIFIER", "Expected target state").value;
-      this.expect("COLON", "Expected :");
-      const event = this.expect("IDENTIFIER", "Expected event name").value;
-      transitions.push({ from, to, event });
+      if (this.isStateMachineTransitionShorthandStart()) {
+        transitions.push(this.parseStateMachineTransitionShorthand());
+      } else {
+        const from = this.parseStateMachineIdentifier("Expected source state");
+        this.expect("ARROW", "Expected ->");
+        const to = this.parseStateMachineIdentifier("Expected target state");
+        this.expect("COLON", "Expected :");
+        const event = this.parseStateMachineIdentifier("Expected event name");
+        transitions.push({ from, to, event });
+      }
       this.skipNewlines();
     }
     this.expect("RBRACE", "Expected }");
     return transitions;
   }
+  parseStateMachineInputDeclaration() {
+    this.advance();
+    const name = this.parseStateMachineIdentifier("Expected input name");
+    this.expect("COLON", "Expected : after input name");
+    const rawType = this.parseStateMachineIdentifier("Expected input type");
+    const inputType = rawType === "number" ? "float" : rawType === "boolean" ? "bool" : rawType;
+    let defaultValue;
+    if (this.check("EQUALS")) {
+      this.advance();
+      defaultValue = this.parseValue();
+    }
+    return {
+      type: "animation-input",
+      name,
+      inputType,
+      rawType,
+      default: defaultValue
+    };
+  }
+  parseStateMachineListenerDeclaration() {
+    this.advance();
+    const event = this.parseStateMachineDottedIdentifier("Expected listener event");
+    this.expect("ARROW", "Expected -> after listener event");
+    if (this.current().value === "fire") {
+      this.advance();
+      return {
+        type: "animation-listener",
+        event,
+        action: "fire",
+        parameter: this.parseStateMachineDottedIdentifier("Expected trigger input")
+      };
+    }
+    if (this.current().value === "reset") {
+      this.advance();
+      return {
+        type: "animation-listener",
+        event,
+        action: "reset",
+        parameter: this.parseStateMachineDottedIdentifier("Expected trigger input")
+      };
+    }
+    const parameter = this.parseStateMachineDottedIdentifier("Expected animation input");
+    this.expect("EQUALS", "Expected = in listener binding");
+    const parsedValue = this.parseValue();
+    const listener = {
+      type: "animation-listener",
+      event,
+      action: "set",
+      parameter
+    };
+    if (parsedValue && typeof parsedValue === "object" && "__ref" in parsedValue) {
+      const ref = parsedValue.__ref;
+      if (typeof ref === "string" && (ref === "event" || ref.startsWith("event."))) {
+        listener.source = ref;
+      } else if (typeof ref === "string") {
+        listener.value = ref;
+      } else {
+        listener.value = String(ref ?? "");
+      }
+    } else if (typeof parsedValue === "number" || typeof parsedValue === "boolean" || typeof parsedValue === "string") {
+      listener.value = parsedValue;
+    } else {
+      listener.value = String(parsedValue ?? "");
+    }
+    return listener;
+  }
+  isStateMachineTransitionShorthandStart() {
+    return this.isStateMachineIdentifierToken(0) && this.peek(1).type === "ARROW";
+  }
+  parseStateMachineTransitionShorthand() {
+    const fromRaw = this.parseStateMachineIdentifier("Expected source state");
+    const from = fromRaw.toLowerCase() === "any" ? "any" : fromRaw;
+    this.expect("ARROW", "Expected ->");
+    const to = this.parseStateMachineIdentifier("Expected target state");
+    const transition = { from, to };
+    while (!this.check("NEWLINE") && !this.check("RBRACE") && !this.check("COMMA") && !this.check("EOF")) {
+      if (!this.isStateMachineIdentifierToken(0)) break;
+      const clause = this.current().value.toLowerCase();
+      this.advance();
+      if (clause === "when") {
+        transition.when = this.parseExpression();
+      } else if (clause === "on") {
+        transition.event = this.parseStateMachineIdentifier("Expected trigger input");
+      } else if (clause === "over" || clause === "duration") {
+        transition.duration = this.parseValue();
+      } else if (clause === "easing") {
+        transition.easing = this.parseStateMachineIdentifier("Expected easing name");
+      } else if (clause === "exittime" || clause === "exit_time") {
+        transition.exitTime = this.parseValue();
+        transition.hasExitTime = true;
+      } else if (clause === "pausewhenexiting" || clause === "pause_when_exiting") {
+        transition.pauseWhenExiting = this.parseOptionalStateMachineBoolean();
+      } else if (clause === "priority") {
+        transition.priority = this.parseValue();
+      } else if (clause === "cantransitiontoself" || clause === "can_transition_to_self") {
+        transition.canTransitionToSelf = this.parseOptionalStateMachineBoolean();
+      } else {
+        break;
+      }
+    }
+    return transition;
+  }
+  parseOptionalStateMachineBoolean() {
+    if (this.check("COLON")) this.advance();
+    if (this.check("BOOLEAN")) return this.advance().value === "true";
+    if (this.check("IDENTIFIER")) {
+      const value = this.current().value.toLowerCase();
+      if (value === "true" || value === "false") {
+        this.advance();
+        return value === "true";
+      }
+    }
+    return true;
+  }
+  parseStateMachineIdentifier(message) {
+    if (this.check("IDENTIFIER") || this.check("STRING")) {
+      return this.advance().value;
+    }
+    return this.expect("IDENTIFIER", message).value;
+  }
+  parseStateMachineDottedIdentifier(message) {
+    let value = this.parseStateMachineIdentifier(message);
+    while (this.check("DOT")) {
+      this.advance();
+      value += `.${this.parseStateMachineIdentifier("Expected property name after dot")}`;
+    }
+    return value;
+  }
+  isStateMachineIdentifierToken(offset) {
+    const token = this.peek(offset);
+    return token.type === "IDENTIFIER" || token.type === "STRING";
+  }
   parseControlFlowBody() {
     const nodes = [];
     if (this.check("LBRACE")) {
@@ -3867,41 +5258,10 @@ var HoloScriptPlusParser = class {
     return nodes;
   }
   parseCodeBlock() {
-    let code = "";
-    let braceDepth = 0;
-    if (this.check("LBRACE")) {
-      this.advance();
-      braceDepth = 1;
-      try {
-        while (braceDepth > 0 && !this.check("EOF")) {
-          const token = this.advance();
-          if (token.type === "LBRACE") {
-            braceDepth++;
-            code += "{";
-          } else if (token.type === "RBRACE") {
-            braceDepth--;
-            if (braceDepth > 0) {
-              code += "}";
-            }
-          } else if (token.type === "STRING") {
-            code += `"${token.value}"`;
-            code += " ";
-          } else {
-            code += token.value;
-            if (token.type === "NEWLINE") {
-              code += "\n";
-            } else {
-              code += " ";
-            }
-          }
-        }
-      } catch (e) {
-        const errorMessage = e instanceof Error ? e.message : String(e);
-        if (errorMessage !== "ParseError") console.error(e);
-        this.synchronize();
-      }
+    if (!this.check("LBRACE")) {
+      return "";
     }
-    return code.trim();
+    return this.parseRawBlock();
   }
   parseInlineExpression() {
     let expr = "";
@@ -4153,6 +5513,9 @@ var HoloScriptPlusParser = class {
       }
       return this.parseParenExpression();
     }
+    if (token.type === "ARROW" && token.value === "->") {
+      return this.parseTransitionShorthand();
+    }
     if (token.type === "MATCH") {
       return this.parseMatchExpression();
     }
@@ -4208,6 +5571,36 @@ var HoloScriptPlusParser = class {
     err.message = "ParseError";
     throw err;
   }
+  /**
+   * Parse a state-machine transition shorthand value:
+   *   -> "target"
+   *   -> "target" action(callback_name)
+   *   -> "target" guard(state.credits >= 10) action(begin)
+   * Used as the value of on_<event> keys inside @state_machine states config.
+   * Modifiers (action / guard) may appear in any order, each at most once
+   * meaningfully (last one wins, matching general object semantics).
+   */
+  parseTransitionShorthand() {
+    this.advance();
+    let target = "";
+    if (this.check("STRING") || this.check("IDENTIFIER")) {
+      target = this.advance().value;
+    } else {
+      this.error(
+        `Expected target state after -> in transition. Got ${this.current().type} "${this.current().value}"`,
+        "HSP300"
+      );
+    }
+    const transition = { type: "transition", target };
+    while (this.check("IDENTIFIER") && (this.current().value === "action" || this.current().value === "guard") && this.peek(1).type === "LPAREN") {
+      const kind = this.advance().value;
+      this.advance();
+      const arg = this.parseExpression();
+      this.expect("RPAREN", `Expected ) after ${kind} argument in transition`);
+      transition[kind] = arg;
+    }
+    return transition;
+  }
   parseParenExpression() {
     this.expect("LPAREN", "Expected (");
     const items = [];
@@ -4592,6 +5985,14 @@ var HoloScriptPlusParser = class {
       })
     );
   }
+  errorAt(token, message, code = "HSP001") {
+    this.errors.push(
+      createRichError(code, message, token.line, token.column, {
+        source: this.source,
+        severity: "error"
+      })
+    );
+  }
   errorWithSuggestion(message, suggestion, code = "HSP001") {
     const token = this.current();
     this.errors.push(
@@ -4846,5 +6247,5 @@ function parse(source, options) {
 }
 
 export { ChunkBasedIncrementalParser, HSPLUS_ERROR_CODES, HoloScriptPlusParser, ParseCache, createKeywordError, createParser, createRichError, createTraitError, findSimilarKeyword, findSimilarTrait, formatRichError, formatRichErrors, getErrorCodeDocumentation, getSourceContext, globalParseCache, parse, parseIncrementalChunks };
-//# sourceMappingURL=chunk-FNHJRI32.js.map
-//# sourceMappingURL=chunk-FNHJRI32.js.map
+//# sourceMappingURL=chunk-DBH3D2MU.js.map
+//# sourceMappingURL=chunk-DBH3D2MU.js.map