@holoscript/core 8.0.7 → 8.0.9

package/dist/{chunk-OABEO6HH.js → chunk-SZOLTWWD.js}

@@ -1,4 +1,5 @@
 import { parsePipeline } from './chunk-SYTRBGDS.js';
+import { ErrorRecovery } from './chunk-Z6LZUYZF.js';
 
 // src/parser/TypoDetector.ts
 var TypoDetector = class {
@@ -170,6 +171,17 @@ var KEYWORDS = {
   waypoints: "WAYPOINTS",
   constraint: "CONSTRAINT",
   terrain: "TERRAIN",
+  // MMO/AAA game constructs (v6.2)
+  loot_table: "LOOT_TABLE",
+  world_chunk: "WORLD_CHUNK",
+  spawn_point: "SPAWN_POINT",
+  game_trigger: "GAME_TRIGGER",
+  movement_path: "MOVEMENT_PATH",
+  reaction_trigger: "REACTION_TRIGGER",
+  world_layer: "WORLD_LAYER",
+  dungeon_instance: "DUNGEON_INSTANCE",
+  world_shard: "WORLD_SHARD",
+  real_estate: "REAL_ESTATE",
   // IoT / Digital Twin
   sensor: "IOT_SENSOR",
   device: "IOT_DEVICE",
@@ -250,6 +262,10 @@ var KEYWORDS = {
   bridge: "WEB3_CONTRACT",
   // Perception & simulation layer (v4.2 — March 2026)
   material: "MATERIAL",
+  material_graph: "MATERIAL_GRAPH",
+  light_field: "LIGHT_FIELD",
+  nav_field: "NAV_FIELD",
+  physics_contract: "PHYSICS_CONTRACT",
   pbr_material: "PBR_MATERIAL",
   unlit_material: "UNLIT_MATERIAL",
   shader: "SHADER",
@@ -271,6 +287,7 @@ var KEYWORDS = {
   particles: "PARTICLES",
   emitter: "EMITTER",
   vfx: "VFX",
+  particle_field: "PARTICLE_FIELD",
   post_processing: "POST_PROCESSING",
   post_fx: "POST_FX",
   render_pipeline: "POST_PROCESSING",
@@ -286,6 +303,7 @@ var KEYWORDS = {
   climate: "WEATHER",
   simulation: "SIMULATION",
   procedural: "PROCEDURAL",
+  pcg_graph: "PCG_GRAPH",
   generate: "PROCEDURAL",
   scatter: "SCATTER",
   distribute: "SCATTER",
@@ -329,6 +347,11 @@ var KEYWORDS = {
   payment_gate: "PAYMENT_GATE",
   subscription: "SUBSCRIPTION",
   tip_jar: "TIP_JAR",
+  // SimulationContract block (v6.3 — NORTH_STAR thesis: simulation IS the proof)
+  sim_contract: "HOLO_CONTRACT",
+  // Pub/sub messaging primitives (v6.4)
+  topic: "HOLO_TOPIC",
+  channel: "HOLO_CHANNEL",
   // v6 Universal domains (v5.4 — Domains Unified)
   service: "SERVICE_BLOCK",
   endpoint: "ENDPOINT_BLOCK",
@@ -760,6 +783,7 @@ var KEYWORDS_AS_IDENTIFIERS = [
   "EFFECTS",
   "CAMERA",
   "BIND",
+  "CONNECT",
   "TIMELINE",
   "AUDIO",
   "ZONE",
@@ -792,7 +816,9 @@ var KEYWORDS_AS_IDENTIFIERS = [
   "COMPOSITION",
   "SPATIAL_GROUP",
   "SPATIAL_AGENT",
-  "SPATIAL_CONTAINER"
+  "SPATIAL_CONTAINER",
+  "HOLO_TOPIC",
+  "HOLO_CHANNEL"
 ];
 function isKeywordAsIdentifierType(api, type) {
   if (api.DOMAIN_TOKENS.has(type)) return true;
@@ -1048,7 +1074,6 @@ function parseObjectExpression(api) {
 
 // src/parser/HoloCompositionParser.ts
 var _HoloCompositionParser = class _HoloCompositionParser {
-  // Track parsing context for better errors
   constructor(options = {}) {
     this.tokens = [];
     this.pos = 0;
@@ -1061,6 +1086,15 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       strict: false,
       ...options
     };
+    this.errorRecovery = new ErrorRecovery(this.options.knownTraits);
+  }
+  /**
+   * The error-recovery engine for this parser, seeded with the injected
+   * `knownTraits` union when one was supplied via parser options. Exposed so
+   * tooling (and tests) can verify the trait-vocabulary seam is wired through.
+   */
+  getErrorRecovery() {
+    return this.errorRecovery;
   }
   /** Instance accessor for the static DOMAIN_TOKENS set — satisfies ExpressionParserApi. */
   get DOMAIN_TOKENS() {
@@ -1135,7 +1169,18 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       domainBlocks: [],
       // v4.5 additions — CRSEC norm lifecycle
       norms: [],
-      metanorms: []
+      metanorms: [],
+      // v6.2 additions — MMO/AAA game constructs
+      spawnPoints: [],
+      triggers: [],
+      lootTables: [],
+      worldChunks: [],
+      worldLayers: [],
+      dungeonInstances: [],
+      worldShards: [],
+      movementPaths: [],
+      reactionTriggers: [],
+      policyPacks: []
     };
     while (!this.isAtEnd()) {
       try {
@@ -1179,8 +1224,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             } else if (decoratorName === "state") {
               composition.state = this.parseStateBody();
             } else if (decoratorName === "state_machine") {
+              const name = this.parseOptionalStateMachineName("implicit");
               if (this.check("LBRACE")) {
-                composition.stateMachines.push(this.parseStateMachineFromDecorator());
+                composition.stateMachines.push(this.parseStateMachineFromDecorator(name));
               }
             } else {
               composition.traits = composition.traits || [];
@@ -1210,7 +1256,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           composition.logic = this.parseLogic();
         } else if (this.check("TIMELINE")) {
           composition.timelines.push(this.parseTimeline());
-        } else if (this.check("STATE")) {
+        } else if (this.check("STATE") && this.peek(1).type !== "COLON") {
           composition.state = this.parseState();
         } else if (this.check("IMPORT")) {
           composition.imports.push(this.parseImport());
@@ -1245,8 +1291,53 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           composition.norms.push(this.parseNormBlock());
         } else if (this.check("METANORM")) {
           composition.metanorms.push(this.parseMetanormBlock());
+        } else if (this.check("HOLO_CONTRACT")) {
+          composition.contract = this.parseContractBlock();
+        } else if (this.check("IDENTIFIER") && this.current().value === "policy_pack") {
+          composition.policyPacks.push(this.parsePolicyPackBlock());
+        } else if (this.check("HOLO_TOPIC")) {
+          if (!composition.topics) composition.topics = [];
+          composition.topics.push(this.parseTopicBlock());
+        } else if (this.check("HOLO_CHANNEL")) {
+          if (!composition.channels) composition.channels = [];
+          composition.channels.push(this.parseChannelBlock());
+        } else if (this.check("CONNECT")) {
+          if (!composition.connections) composition.connections = [];
+          composition.connections.push(this.parseConnectionStmt());
+        } else if (this.check("IDENTIFIER") && this.current().value === "shareplay") {
+          composition.metadata = {
+            ...composition.metadata ?? {},
+            shareplay: this.parseSharePlayBlock()
+          };
+        } else if (this.isLooseOnHandlerStart()) {
+          this.skipLooseOnHandler();
+        } else if (this.check("LOOT_TABLE")) {
+          composition.lootTables.push(this.parseLootTable());
+        } else if (this.check("WORLD_CHUNK")) {
+          composition.worldChunks.push(this.parseWorldChunk());
+        } else if (this.check("SPAWN_POINT")) {
+          composition.spawnPoints.push(this.parseSpawnPoint());
+        } else if (this.check("GAME_TRIGGER")) {
+          composition.triggers.push(this.parseGameTrigger());
+        } else if (this.check("MOVEMENT_PATH")) {
+          composition.movementPaths.push(this.parseMovementPath());
+        } else if (this.check("REACTION_TRIGGER")) {
+          composition.reactionTriggers.push(this.parseReactionTrigger());
+        } else if (this.check("WORLD_LAYER")) {
+          composition.worldLayers.push(this.parseWorldLayer());
+        } else if (this.check("DUNGEON_INSTANCE")) {
+          composition.dungeonInstances.push(this.parseDungeonInstance());
+        } else if (this.check("WORLD_SHARD")) {
+          composition.worldShards.push(this.parseWorldShard());
+        } else if (this.check("REAL_ESTATE")) {
+          composition.domainBlocks.push(this.parseDomainBlock());
+        } else if (this.check("SCENE")) {
+          if (!composition.scenes) composition.scenes = [];
+          composition.scenes.push(this.parseScene());
         } else if (this.isDomainBlockToken()) {
           composition.domainBlocks.push(this.parseDomainBlock());
+        } else if (this.isLooseDomainBlockStart() || this.isLooseNamedDomainBlockStart()) {
+          composition.domainBlocks.push(this.parseDomainBlock());
         } else if (this.check("MODULE")) {
           this.advance();
           if (this.check("STRING")) this.expectString();
@@ -1302,12 +1393,18 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       this.expect("LBRACE");
       this.skipNewlines();
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
-        const key = this.expectIdentifier();
-        this.expect("COLON");
-        const value = this.parseValue();
-        properties.push({ type: "EnvironmentProperty", key, value });
+        if (this.isPropertyName() && this.peek(1).type === "LBRACE") {
+          const key = this.parsePropertyKey();
+          const value = this.parseBlockTraitConfig();
+          properties.push({ type: "EnvironmentProperty", key, value });
+        } else {
+          const key = this.parsePropertyKey();
+          this.expect("COLON");
+          const value = this.parseValue();
+          properties.push({ type: "EnvironmentProperty", key, value });
+        }
         this.skipNewlines();
       }
       this.expect("RBRACE");
@@ -1337,15 +1434,15 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       this.expect("LBRACE");
       this.skipNewlines();
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
         if (this.check("AT")) {
           this.advance();
           const traitName = this.expectIdentifier();
           const config = this.parseOptionalTraitConfig();
           traits.push({ type: "ObjectTrait", name: traitName, config });
-        } else if (this.check("IDENTIFIER")) {
-          const key = this.expectIdentifier();
+        } else if (this.isPropertyName()) {
+          const key = this.parsePropertyKey();
           if (this.check("COLON")) {
             this.advance();
             properties.push({ type: "ObjectProperty", key, value: this.parseValue() });
@@ -1433,13 +1530,31 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       domainBlocks: [],
       // v4.5 additions — CRSEC norm lifecycle
       norms: [],
-      metanorms: []
+      metanorms: [],
+      // v6.2 additions — MMO/AAA game constructs
+      spawnPoints: [],
+      triggers: [],
+      lootTables: [],
+      worldChunks: [],
+      worldLayers: [],
+      dungeonInstances: [],
+      worldShards: [],
+      movementPaths: [],
+      reactionTriggers: [],
+      policyPacks: []
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
       try {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
-        if (this.check("IMPORT")) {
+        if (this.peek(1).type === "COLON" && (this.isPropertyName() || this.check("METADATA_BLOCK"))) {
+          const key = this.advance().value;
+          this.advance();
+          const value = !this.check("RBRACE") && !this.isAtEnd() ? this.parseValue() : null;
+          if (key === "metadata" && value && typeof value === "object" && !Array.isArray(value)) {
+            composition.metadata = { ...composition.metadata ?? {}, ...value };
+          }
+        } else if (this.check("IMPORT")) {
           composition.imports.push(this.parseImport());
         } else if (this.check("THEME")) {
           composition.theme = this.parseTheme();
@@ -1448,7 +1563,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         } else if (this.check("SCENE")) {
           if (!composition.scenes) composition.scenes = [];
           composition.scenes.push(this.parseScene());
-        } else if (this.check("STATE")) {
+        } else if (this.check("STATE") && this.peek(1).type !== "COLON") {
           composition.state = this.parseState();
         } else if (this.check("METADATA_BLOCK")) {
           this.advance();
@@ -1520,8 +1635,48 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           composition.norms.push(this.parseNormBlock());
         } else if (this.check("METANORM")) {
           composition.metanorms.push(this.parseMetanormBlock());
+        } else if (this.check("HOLO_CONTRACT")) {
+          composition.contract = this.parseContractBlock();
+        } else if (this.check("IDENTIFIER") && this.current().value === "policy_pack") {
+          composition.policyPacks.push(this.parsePolicyPackBlock());
+        } else if (this.check("HOLO_TOPIC")) {
+          if (!composition.topics) composition.topics = [];
+          composition.topics.push(this.parseTopicBlock());
+        } else if (this.check("HOLO_CHANNEL")) {
+          if (!composition.channels) composition.channels = [];
+          composition.channels.push(this.parseChannelBlock());
+        } else if (this.check("CONNECT")) {
+          if (!composition.connections) composition.connections = [];
+          composition.connections.push(this.parseConnectionStmt());
+        } else if (this.check("IDENTIFIER") && this.current().value === "shareplay") {
+          composition.metadata = {
+            ...composition.metadata ?? {},
+            shareplay: this.parseSharePlayBlock()
+          };
+        } else if (this.check("LOOT_TABLE")) {
+          composition.lootTables.push(this.parseLootTable());
+        } else if (this.check("WORLD_CHUNK")) {
+          composition.worldChunks.push(this.parseWorldChunk());
+        } else if (this.check("SPAWN_POINT")) {
+          composition.spawnPoints.push(this.parseSpawnPoint());
+        } else if (this.check("GAME_TRIGGER")) {
+          composition.triggers.push(this.parseGameTrigger());
+        } else if (this.check("MOVEMENT_PATH")) {
+          composition.movementPaths.push(this.parseMovementPath());
+        } else if (this.check("REACTION_TRIGGER")) {
+          composition.reactionTriggers.push(this.parseReactionTrigger());
+        } else if (this.check("WORLD_LAYER")) {
+          composition.worldLayers.push(this.parseWorldLayer());
+        } else if (this.check("DUNGEON_INSTANCE")) {
+          composition.dungeonInstances.push(this.parseDungeonInstance());
+        } else if (this.check("WORLD_SHARD")) {
+          composition.worldShards.push(this.parseWorldShard());
+        } else if (this.check("REAL_ESTATE")) {
+          composition.domainBlocks.push(this.parseDomainBlock());
         } else if (this.isDomainBlockToken()) {
           composition.domainBlocks.push(this.parseDomainBlock());
+        } else if (this.isLooseDomainBlockStart() || this.isLooseNamedDomainBlockStart()) {
+          composition.domainBlocks.push(this.parseDomainBlock());
         } else if (this.check("MODULE")) {
           composition.domainBlocks.push(this.parseDomainBlock());
         } else if (this.check("AT")) {
@@ -1562,8 +1717,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             } else if (decoratorName === "world" || decoratorName === "environment") {
               composition.environment = this.parseEnvironmentBody();
             } else if (decoratorName === "state_machine") {
+              const name2 = this.parseOptionalStateMachineName("implicit");
               if (this.check("LBRACE")) {
-                composition.stateMachines.push(this.parseStateMachineFromDecorator());
+                composition.stateMachines.push(this.parseStateMachineFromDecorator(name2));
               }
             } else {
               composition.traits = composition.traits || [];
@@ -1574,6 +1730,8 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         } else if (this.check("ACTION") || this.check("ASYNC")) {
           composition.actions = composition.actions || [];
           composition.actions.push(this.parseAction());
+        } else if (this.check("FUNCTION")) {
+          this.skipFunctionDeclaration();
         } else if (this.check("USING")) {
           this.advance();
           if (this.check("STRING") || this.check("IDENTIFIER")) this.advance();
@@ -1581,27 +1739,8 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             this.advance();
             if (this.check("IDENTIFIER")) this.advance();
           }
-        } else if (this.check("IDENTIFIER") && this.current().value === "on" && this.peek(1).type === "IDENTIFIER") {
-          const eventName = this.peek(1).value;
-          this.advance();
-          this.advance();
-          while (this.check("DOT")) {
-            this.advance();
-            if (this.check("IDENTIFIER")) this.advance();
-          }
-          let parameters = [];
-          if (this.check("LPAREN")) {
-            parameters = this.parseParameterList();
-          }
-          if (this.check("LBRACE")) this.skipBlock();
-          composition.eventHandlers = composition.eventHandlers || [];
-          composition.eventHandlers.push({
-            type: "EventHandler",
-            event: eventName,
-            parameters,
-            body: []
-            // Skipped body
-          });
+        } else if (this.isLooseOnHandlerStart()) {
+          this.skipLooseOnHandler();
         } else if (this.check("COLON")) {
           this.advance();
           if (!this.check("RBRACE") && !this.isAtEnd()) this.parseValue();
@@ -1630,6 +1769,10 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           if (this.check("COLON")) {
             this.advance();
             if (!this.check("RBRACE") && !this.isAtEnd()) this.parseValue();
+          } else if (this.check("LBRACKET")) {
+            this.advance();
+            while (!this.check("RBRACKET") && !this.isAtEnd()) this.advance();
+            if (this.check("RBRACKET")) this.advance();
           } else {
             if (this.check("STRING") || this.check("IDENTIFIER")) this.advance();
             if (this.check("LPAREN")) this.skipParens();
@@ -1778,7 +1921,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("PARTICLES") || this.check("PARTICLE_SYSTEM")) {
         const ps = this.parseParticleSystem();
@@ -1787,15 +1930,16 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           key: ps.name,
           value: ps
         });
+      } else if (this.isPropertyName() && this.peek(1).type === "LBRACE") {
+        const key = this.parsePropertyKey();
+        const value = this.parseBlockTraitConfig();
+        properties.push({ type: "EnvironmentProperty", key, value });
       } else {
-        const key = this.expectIdentifier();
+        const key = this.parsePropertyKey();
         this.expect("COLON");
         const value = this.parseValue();
         properties.push({ type: "EnvironmentProperty", key, value });
       }
-      if (this.check("SEMICOLON")) {
-        this.advance();
-      }
       this.skipNewlines();
     }
     this.expect("RBRACE");
@@ -1825,14 +1969,19 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     let environment;
     const objects = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("ENVIRONMENT")) {
         environment = this.parseEnvironment();
       } else if (this.check("OBJECT")) {
         objects.push(this.parseObject());
+      } else if (this.check("LBRACE")) {
+        this.skipBlock();
       } else {
         this.advance();
+        if (this.check("STRING") || this.check("IDENTIFIER")) this.advance();
+        if (this.check("LPAREN")) this.skipParens();
+        if (this.check("LBRACE")) this.skipBlock();
       }
     }
     this.expect("RBRACE");
@@ -1856,7 +2005,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = {};
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -1894,24 +2043,18 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         this.advance();
       }
     }
+    const inlineTraitProperties = [];
+    while (this.check("AT")) {
+      inlineTraitProperties.push(this.parseTraitAsLightProperty(true));
+    }
     this.expect("LBRACE");
     this.skipNewlines();
-    const properties = [];
+    const properties = [...inlineTraitProperties];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("AT")) {
-        this.advance();
-        const traitName = this.parseTraitName();
-        const cfg = this.parseOptionalTraitConfig();
-        const cfgKeys = Object.keys(cfg);
-        let traitValue;
-        if (cfgKeys.length === 0) traitValue = true;
-        else if (cfgKeys.every((k) => /^_arg\d+$/.test(k))) {
-          const arr = cfgKeys.sort().map((k) => cfg[k]);
-          traitValue = arr.length === 1 ? arr[0] : arr;
-        } else traitValue = cfg;
-        properties.push({ type: "LightProperty", key: traitName, value: traitValue });
+        properties.push(this.parseTraitAsLightProperty());
         this.skipNewlines();
         continue;
       }
@@ -1947,6 +2090,19 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       properties
     };
   }
+  parseTraitAsLightProperty(requireBodyAfterBareBrace = false) {
+    this.expect("AT");
+    const traitName = this.parseTraitName();
+    const cfg = this.parseOptionalTraitConfig(requireBodyAfterBareBrace);
+    const cfgKeys = Object.keys(cfg);
+    let traitValue;
+    if (cfgKeys.length === 0) traitValue = true;
+    else if (cfgKeys.every((k) => /^_arg\d+$/.test(k))) {
+      const arr = cfgKeys.sort().map((k) => cfg[k]);
+      traitValue = arr.length === 1 ? arr[0] : arr;
+    } else traitValue = cfg;
+    return { type: "LightProperty", key: traitName, value: traitValue };
+  }
   // ===========================================================================
   // EFFECTS (post-processing block)
   // ===========================================================================
@@ -1957,14 +2113,14 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const effects = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const effectType = this.expectIdentifier();
       this.expect("LBRACE");
       this.skipNewlines();
       const properties = {};
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
         const key = this.expectIdentifier();
         this.expect("COLON");
@@ -2006,7 +2162,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("AT")) {
         this.advance();
@@ -2047,7 +2203,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     let autoplay;
     let loop;
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("IDENTIFIER") && (this.current().value === "autoplay" || this.current().value === "loop")) {
         const key = this.advance().value;
@@ -2086,7 +2242,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       this.skipNewlines();
       const properties = {};
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
         const key = this.expectIdentifier();
         this.expect("COLON");
@@ -2131,7 +2287,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("AT")) {
         this.advance();
@@ -2170,7 +2326,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     const properties = [];
     const handlers = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("IDENTIFIER") && this.current().value.startsWith("on_")) {
         const event = this.advance().value;
@@ -2210,7 +2366,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const elements = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       if (this.check("ELEMENT")) {
         elements.push(this.parseUIElement());
@@ -2235,7 +2391,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -2262,7 +2418,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -2396,7 +2552,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -2431,11 +2587,11 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       // Initialize directives
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
-      if (this.check("STATE")) {
+      if (this.check("STATE") && this.peek(1).type !== "COLON") {
         template.state = this.parseState();
-      } else if (this.check("ACTION") || this.check("ASYNC")) {
+      } else if (this.check("ACTION") && this.peek(1).type !== "COLON" || this.check("ASYNC")) {
         const action = this.parseAction();
         template.actions.push(action);
         template.directives.push({
@@ -2500,7 +2656,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           body: []
         });
       } else if (this.isPropertyName() && this.peek(1).type === "LPAREN") {
-        const methodName = this.expectIdentifier();
+        const methodName = this.parsePropertyKey();
         this.skipParens();
         if (this.check("LBRACE")) {
           this.skipBlock();
@@ -2512,7 +2668,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           });
         }
       } else if (this.isPropertyName() && (this.peek(1).type === "IDENTIFIER" || this.peek(1).type === "STRING")) {
-        const blockType = this.expectIdentifier();
+        const blockType = this.parsePropertyKey();
         const blockName = this.check("STRING") ? this.advance().value : this.expectIdentifier();
         if (this.check("LPAREN")) {
           this.skipParens();
@@ -2527,7 +2683,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           });
         }
       } else if (this.isPropertyName() && this.peek(1).type === "LBRACE") {
-        const blockType = this.expectIdentifier();
+        const blockType = this.parsePropertyKey();
         if (this.check("LBRACE")) {
           this.skipBlock();
           template.directives.push({
@@ -2538,12 +2694,12 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           });
         }
       } else {
-        const key = this.expectIdentifier();
+        const key = this.parsePropertyKey();
         this.expect("COLON");
         const value = this.parseValue();
         template.properties.push({ type: "TemplateProperty", key, value });
       }
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
     }
     this.expect("RBRACE");
     template.loc = { start: startLoc, end: this.currentLocation() };
@@ -2563,8 +2719,8 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     let name = "";
     if (this.check("STRING")) {
       name = this.expectString();
-    } else if (this.check("IDENTIFIER")) {
-      name = this.expectIdentifier();
+    } else if (this.isObjectNameToken()) {
+      name = this.advance().value;
     } else if (typeOverride === "behavior" && this.check("LBRACE")) {
       name = "behavior";
     } else {
@@ -2598,14 +2754,14 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     const directives = [];
     let state;
     while (!this.check("RBRACE") && !this.check("EOF")) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
-      if (this.check("OBJECT") || this.check("SPATIAL_AGENT") || this.check("TOOL_SLOT") || this.check("BEHAVIOR") || this.current().type.startsWith("UI_")) {
+      if (this.check("OBJECT") || this.check("SPATIAL_AGENT") || this.check("TOOL_SLOT") || this.check("BEHAVIOR") && this.peek(1).type !== "COLON" || this.current().type.startsWith("UI_")) {
         const nestedType = this.check("OBJECT") ? void 0 : this.current().value.toLowerCase();
         children.push(this.parseObject(nestedType));
       } else if (this.check("SUB_ORB")) {
         subOrbs.push(this.parseSubOrb());
-      } else if (this.check("ACTION") || this.check("ASYNC")) {
+      } else if (this.check("ACTION") && this.peek(1).type !== "COLON" || this.check("ASYNC")) {
         const action = this.parseAction();
         directives.push({
           type: "method",
@@ -2656,7 +2812,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
               config: config2,
               platformConstraint: constraint
             });
-          } else if (this.check("OBJECT") || this.check("SPATIAL_AGENT") || this.check("TOOL_SLOT") || this.check("BEHAVIOR") || this.current().type.startsWith("UI_")) {
+          } else if (this.check("OBJECT") || this.check("SPATIAL_AGENT") || this.check("TOOL_SLOT") || this.check("BEHAVIOR") && this.peek(1).type !== "COLON" || this.current().type.startsWith("UI_")) {
             const nestedType = this.check("OBJECT") ? void 0 : this.current().value.toLowerCase();
             const child = this.parseObject(nestedType);
             child.platformConstraint = constraint;
@@ -2669,7 +2825,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         const trait = { type: "ObjectTrait", name: traitName, config };
         traits.push(trait);
         directives.push({ type: "trait", name: traitName, config });
-      } else if (this.check("STATE")) {
+      } else if (this.check("STATE") && this.peek(1).type !== "COLON") {
         state = this.parseState();
       } else if (this.isDomainBlockToken() && this.peek(1).type !== "COLON") {
         const domainBlock = this.parseDomainBlock();
@@ -2681,7 +2837,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         const physicsValue = this.parseValue();
         properties.push({ type: "ObjectProperty", key, value: physicsValue });
       } else if (this.isPropertyName()) {
-        const key = this.advance().value;
+        const key = this.parsePropertyKey();
         if (this.check("COLON")) {
           this.advance();
           if (this.check("LBRACE")) {
@@ -2715,7 +2871,11 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           if (this.check("LPAREN")) this.skipParens();
           let parsedBody = "";
           if (this.check("LBRACE")) {
-            parsedBody = this.parseBlockTraitConfig();
+            if (key === "on" || key.startsWith("on_") || /^on[A-Z]/.test(key)) {
+              this.skipBlock();
+            } else {
+              parsedBody = this.parseBlockTraitConfig();
+            }
           }
           directives.push({ type: key, name: blockName, parameters: [], body: parsedBody });
         } else if (this.check("LBRACE")) {
@@ -2863,6 +3023,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.expect("LBRACE");
     this.skipNewlines();
     const objects = [];
+    const lights = [];
     const groups = [];
     const body = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
@@ -2870,6 +3031,8 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       if (this.check("RBRACE")) break;
       if (this.check("OBJECT")) {
         objects.push(this.parseObject());
+      } else if (this.check("LIGHT")) {
+        lights.push(this.parseLight());
       } else if (this.check("SPATIAL_GROUP")) {
         groups.push(this.parseSpatialGroup());
       } else if (this.check("TEMPLATE")) {
@@ -2922,6 +3085,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       name,
       properties,
       objects,
+      lights: lights.length > 0 ? lights : void 0,
       groups: groups.length > 0 ? groups : void 0,
       body: body.length > 0 ? body : void 0
     };
@@ -2941,6 +3105,18 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       if (this.check("RBRACE")) break;
       if (this.check("ACTION") || this.check("ASYNC")) {
         actions.push(this.parseAction());
+      } else if (this.check("FUNCTION")) {
+        this.skipFunctionDeclaration();
+      } else if (this.check("IDENTIFIER") && this.current().value === "on" && (this.peek(1).type === "STRING" || this.peek(1).type === "IDENTIFIER")) {
+        this.advance();
+        const event = this.advance().value;
+        const parameters = this.check("LPAREN") ? this.parseParameterList() : [];
+        if (this.check("LBRACE")) {
+          this.skipBlock();
+          handlers.push({ type: "EventHandler", event, parameters, body: [] });
+        } else {
+          handlers.push({ type: "EventHandler", event, parameters, body: [] });
+        }
       } else if (this.check("IDENTIFIER")) {
         const name = this.advance().value;
         if (this.check("IDENTIFIER")) {
@@ -3321,6 +3497,12 @@ var _HoloCompositionParser = class _HoloCompositionParser {
   isKeywordAsIdentifier() {
     return isKeywordAsIdentifier(this._exprApi);
   }
+  isObjectNameToken() {
+    const type = this.current().type;
+    if (type === "IDENTIFIER") return true;
+    if (type === "OBJECT") return false;
+    return this.isKeywordAsIdentifierType(type);
+  }
   // ===========================================================================
   // VALUES
   // ===========================================================================
@@ -3348,14 +3530,22 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       return this.parseBindValue();
     }
     if (this.match("AT")) {
-      if (this.check("IDENTIFIER")) {
-        return `@${this.advance().value}`;
-      }
+      const traitName = this.parseTraitName();
+      if (traitName) return `@${traitName}`;
       this.error(`Expected trait name after '@', got ${this.current().type}`);
       return null;
     }
-    if (this.match("IDENTIFIER")) {
-      return this.previous().value;
+    if (this.match("HASH")) {
+      return this.parseHashLiteral();
+    }
+    if (this.check("ENUM")) {
+      return this.parseEnumTypeSpec();
+    }
+    if (this.check("FUNCTION")) {
+      return this.parseFunctionValue();
+    }
+    if (this.isBarewordPathToken()) {
+      return this.parseBarewordPathValue();
     }
     if (this.match("LBRACKET")) {
       return this.parseArrayValue();
@@ -3363,13 +3553,148 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     if (this.match("LBRACE")) {
       return this.parseObjectValue();
     }
-    if (_HoloCompositionParser.DOMAIN_TOKENS.has(this.current().type) || this.isKeywordAsIdentifierType(this.current().type)) {
-      return this.advance().value;
-    }
     this.error(`Expected value, got ${this.current().type}`);
     this.advance();
     return null;
   }
+  /**
+   * Parse an `enum(...)` type-spec expression, e.g.:
+   *   enum("button" | "slider" | "checkbox")
+   *
+   * Returns the canonical string representation so trait loaders and schema
+   * emitters can read it as a type annotation. Called from parseValue() when
+   * the current token is ENUM (the keyword `enum` tokenized as 'ENUM' rather
+   * than 'IDENTIFIER').
+   *
+   * The opening `enum` token is consumed here. The caller should check for a
+   * trailing `= defaultValue` if the context supports it (e.g. parseObjectValue).
+   */
+  parseEnumTypeSpec() {
+    this.advance();
+    let spec = "enum";
+    if (this.check("LPAREN")) {
+      spec += this.parseParenthesizedLiteral();
+    }
+    return spec;
+  }
+  parseFunctionValue() {
+    this.expect("FUNCTION");
+    let name = "";
+    if (this.check("STRING") || this.check("IDENTIFIER")) {
+      name = this.advance().value;
+    }
+    const params = this.check("LPAREN") ? this.collectFunctionParameterNames() : [];
+    if (this.check("LBRACE")) {
+      this.skipBlock();
+    }
+    return {
+      type: "FunctionValue",
+      name,
+      params
+    };
+  }
+  skipFunctionDeclaration() {
+    this.expect("FUNCTION");
+    if (this.check("STRING") || this.check("IDENTIFIER")) {
+      this.advance();
+    }
+    if (this.check("LPAREN")) {
+      this.skipParens();
+    }
+    if (this.check("LBRACE")) {
+      this.skipBlock();
+    }
+  }
+  collectFunctionParameterNames() {
+    const params = [];
+    if (!this.check("LPAREN")) return params;
+    this.advance();
+    let parenDepth = 1;
+    while (parenDepth > 0 && !this.isAtEnd()) {
+      if (this.check("LPAREN")) {
+        parenDepth++;
+        this.advance();
+        continue;
+      }
+      if (this.check("RPAREN")) {
+        parenDepth--;
+        this.advance();
+        continue;
+      }
+      if (parenDepth === 1 && this.check("IDENTIFIER")) {
+        params.push(this.advance().value);
+        continue;
+      }
+      this.advance();
+    }
+    return params;
+  }
+  isBarewordPathToken(token = this.current()) {
+    const type = token.type;
+    return type === "IDENTIFIER" || type === "STATE" || _HoloCompositionParser.DOMAIN_TOKENS.has(type) || this.isKeywordAsIdentifierType(type);
+  }
+  parseBarewordPathValue() {
+    let value = this.advance().value;
+    while (this.match("DOT")) {
+      if (!this.isBarewordPathToken()) {
+        this.error(`Expected identifier after '.', got ${this.current().type}`);
+        break;
+      }
+      value += `.${this.advance().value}`;
+    }
+    while (this.check("COLON") && this.isBarewordPathToken(this.peek(1))) {
+      this.advance();
+      value += `:${this.advance().value}`;
+    }
+    if (this.match("LESS")) {
+      value += "<";
+      let depth = 1;
+      while (depth > 0 && !this.isAtEnd()) {
+        if (this.check("LESS")) {
+          depth++;
+          value += this.advance().value;
+          continue;
+        }
+        if (this.check("GREATER")) {
+          depth--;
+          this.advance();
+          value += ">";
+          if (depth === 0) break;
+          continue;
+        }
+        value += this.advance().value;
+      }
+    }
+    if (this.check("LPAREN")) {
+      value += this.parseParenthesizedLiteral();
+    }
+    return value;
+  }
+  parseHashLiteral() {
+    let value = "#";
+    while (!this.isAtEnd()) {
+      if (this.check("IDENTIFIER") || this.check("NUMBER") || this.check("MINUS") || this.check("DOT")) {
+        value += this.advance().value;
+        continue;
+      }
+      break;
+    }
+    return value;
+  }
+  parseParenthesizedLiteral() {
+    let value = "";
+    if (!this.check("LPAREN")) return value;
+    let depth = 0;
+    while (!this.isAtEnd()) {
+      const token = this.current();
+      if (token.type === "LPAREN") depth++;
+      if (token.type === "RPAREN") depth--;
+      value += token.type === "STRING" ? `"${token.value}"` : token.value;
+      this.advance();
+      if (depth === 0) break;
+    }
+    return value;
+  }
   parseBindValue() {
     this.expect("BIND");
     this.expect("LPAREN");
@@ -3395,9 +3720,10 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     const elements = [];
     while (!this.check("RBRACKET") && !this.isAtEnd()) {
       this.skipNewlines();
+      if (this.check("RBRACKET")) break;
       elements.push(this.parseValue());
       this.skipNewlines();
-      if (!this.match("COMMA")) break;
+      this.match("COMMA");
       this.skipNewlines();
     }
     this.skipNewlines();
@@ -3408,13 +3734,15 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const obj = {};
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
-      this.match("COMMA");
-      if (this.isPropertyName() && this.peek(1).type === "COLON") {
-        const key = this.expectIdentifier();
+      if (this.isPropertyAssignmentStart()) {
+        const key = this.parsePropertyKey();
         this.expect("COLON");
         obj[key] = this.parseValue();
+        if (this.match("EQUALS")) {
+          this.parseValue();
+        }
       } else if (this.check("RBRACE")) {
         break;
       } else {
@@ -3497,7 +3825,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const properties = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -3538,6 +3866,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       "QUEST",
       "ABILITY",
       "DIALOGUE",
+      "BEHAVIOR",
       "SHAPE",
       "IMPORT",
       "USING",
@@ -3556,10 +3885,42 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       "WAYPOINTS",
       "CONSTRAINT",
       "TERRAIN",
-      "PARTICLES"
+      "PARTICLES",
+      "METADATA_BLOCK",
+      "HOLO_TOPIC",
+      "HOLO_CHANNEL",
+      "CONNECT",
+      "BIND"
     ];
     return validPropertyKeywords.includes(type);
   }
+  isPropertyNameToken(token) {
+    return token.type === "IDENTIFIER" || _HoloCompositionParser.DOMAIN_TOKENS.has(token.type) || this.isKeywordAsIdentifierType(token.type);
+  }
+  isPropertyAssignmentStart() {
+    if (!this.isPropertyName()) return false;
+    let index = this.pos + 1;
+    if (this.tokens[index]?.type === "QUESTION") index++;
+    while (this.tokens[index]?.type === "DOT" && this.isPropertyNameToken(this.tokens[index + 1])) {
+      index += 2;
+      if (this.tokens[index]?.type === "QUESTION") index++;
+    }
+    return this.tokens[index]?.type === "COLON";
+  }
+  parsePropertyKey() {
+    const parts = [];
+    parts.push(this.isPropertyName() ? this.advance().value : this.expectIdentifier());
+    while (this.match("DOT")) {
+      if (!this.isPropertyName()) {
+        this.error(`Expected identifier after '.', got ${this.current().type}`);
+        break;
+      }
+      parts.push(this.advance().value);
+    }
+    let key = parts.join(".");
+    if (this.match("QUESTION")) key += "?";
+    return key;
+  }
   /**
    * Parse primitive#id or primitive #id { } syntax
    * Examples:
@@ -3597,15 +3958,15 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       this.expect("LBRACE");
       this.skipNewlines();
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
         if (this.check("AT")) {
           this.advance();
           const name = this.parseTraitName();
           const config = this.parseOptionalTraitConfig();
           traits.push({ type: "ObjectTrait", name, config });
-        } else if (this.check("IDENTIFIER")) {
-          const key = this.expectIdentifier();
+        } else if (this.isPropertyName()) {
+          const key = this.parsePropertyKey();
           if (this.check("COLON")) {
             this.advance();
             properties.push({ type: "ObjectProperty", key, value: this.parseValue() });
@@ -3741,6 +4102,15 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     while (this.match("NEWLINE")) {
     }
   }
+  skipBlockMemberSeparators() {
+    this.skipNewlines();
+    while (this.matchBlockMemberSeparator()) {
+      this.skipNewlines();
+    }
+  }
+  matchBlockMemberSeparator() {
+    return this.match("COMMA") || this.match("SEMICOLON");
+  }
   currentLocation() {
     const token = this.current();
     return { line: token.line, column: token.column };
@@ -3828,16 +4198,14 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     while (!this.check("RPAREN") && !this.check("EOF")) {
       this.skipNewlines();
       if (this.check("RPAREN")) break;
-      if (!this.isPropertyName() || this.peek(1).type !== "COLON") {
+      if (!this.isPropertyAssignmentStart()) {
         config[`_arg${argIndex++}`] = this.parseValue();
       } else {
-        const key = this.expectIdentifier();
+        const key = this.parsePropertyKey();
         this.expect("COLON");
         config[key] = this.parseValue();
       }
-      if (this.check("COMMA")) {
-        this.advance();
-      }
+      this.matchBlockMemberSeparator();
       this.skipNewlines();
     }
     this.expect("RPAREN");
@@ -3848,19 +4216,128 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.skipNewlines();
     const config = {};
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
-      const key = this.expectIdentifier();
-      this.expect("COLON");
-      config[key] = this.parseValue();
-      if (this.check("COMMA")) {
+      if (this.isNamedOrTraitedPropertyBlockStart()) {
+        const { key, value } = this.parseNamedOrTraitedPropertyBlock();
+        config[key] = value;
+      } else if (this.check("AT")) {
         this.advance();
+        const traitName = this.parseTraitName();
+        if (traitName) {
+          config[`@${traitName}`] = this.parseOptionalTraitConfig();
+        }
+      } else if (this.isPropertyName() && this.peek(1).type === "LBRACE") {
+        const nestedKey = this.parsePropertyKey();
+        config[nestedKey] = this.parseBlockTraitConfig();
+      } else {
+        const key = this.parsePropertyKey();
+        this.expect("COLON");
+        config[key] = this.parseInlineExpressionTail(this.parseValue());
       }
+      this.matchBlockMemberSeparator();
       this.skipNewlines();
     }
     this.expect("RBRACE");
     return config;
   }
+  parseInlineExpressionTail(value) {
+    if (value === null || typeof value === "object" && !Array.isArray(value) || !this.isInlineExpressionTailStart()) {
+      return value;
+    }
+    let text = String(value);
+    while (!this.check(["NEWLINE", "COMMA", "SEMICOLON", "RBRACE", "RPAREN", "RBRACKET", "EOF"])) {
+      const token = this.current();
+      const raw = token.type === "STRING" ? `"${token.value}"` : token.value;
+      text += ` ${raw}`;
+      this.advance();
+    }
+    return text;
+  }
+  isInlineExpressionTailStart() {
+    return this.check([
+      "EQUALS_EQUALS",
+      "BANG_EQUALS",
+      "LESS",
+      "LESS_EQUALS",
+      "GREATER",
+      "GREATER_EQUALS",
+      "AND",
+      "OR",
+      "PLUS",
+      "MINUS",
+      "STAR",
+      "SLASH"
+    ]);
+  }
+  isNamedOrTraitedPropertyBlockStart() {
+    if (!this.isPropertyName()) return false;
+    let index = this.pos + 1;
+    const hasName = this.tokens[index]?.type === "STRING" || this.tokens[index]?.type === "IDENTIFIER";
+    if (hasName) {
+      index++;
+    }
+    while (this.tokens[index]?.type === "NEWLINE") index++;
+    let hasTrait = false;
+    while (this.tokens[index]?.type === "AT") {
+      hasTrait = true;
+      index++;
+      if (this.tokens[index]?.type === "EOF") return false;
+      index++;
+      if (this.tokens[index]?.type === "LPAREN") {
+        index = this.indexAfterBalancedTokens(index, "LPAREN", "RPAREN");
+      }
+      while (this.tokens[index]?.type === "NEWLINE") index++;
+    }
+    return (hasName || hasTrait) && this.tokens[index]?.type === "LBRACE";
+  }
+  indexAfterBalancedTokens(startIndex, openType, closeType) {
+    let depth = 0;
+    let index = startIndex;
+    while (index < this.tokens.length) {
+      if (this.tokens[index].type === openType) depth++;
+      if (this.tokens[index].type === closeType) {
+        depth--;
+        index++;
+        if (depth === 0) return index;
+        continue;
+      }
+      index++;
+    }
+    return index;
+  }
+  parseNamedOrTraitedPropertyBlock() {
+    const key = this.parsePropertyKey();
+    const name = this.check("STRING") || this.check("IDENTIFIER") ? this.advance().value : void 0;
+    const traits = this.parseInlineTraitNamesBeforeBlock();
+    const body = this.check("LBRACE") ? this.parseBlockTraitConfig() : {};
+    return {
+      key,
+      value: {
+        ...name !== void 0 ? { name } : {},
+        ...traits.length > 0 ? { traits } : {},
+        ...body
+      }
+    };
+  }
+  parseInlineTraitNamesBeforeBlock() {
+    const traits = [];
+    while (this.check("AT")) {
+      this.advance();
+      const traitName = this.parseTraitName();
+      if (traitName) traits.push(traitName);
+      if (this.check("LPAREN")) {
+        this.skipParens();
+      }
+      this.skipNewlines();
+    }
+    return traits;
+  }
+  parseSharePlayBlock() {
+    this.advance();
+    if (!this.check("LBRACE")) return {};
+    return this.parseBlockTraitConfig();
+  }
   // ===========================================================================
   // PLATFORM CONSTRAINT PARSING
   // ===========================================================================
@@ -3976,7 +4453,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       type: "NPC",
       name,
       properties: [],
-      behaviors: []
+      behaviors: [],
+      traits: [],
+      directives: []
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
       this.skipNewlines();
@@ -3985,29 +4464,86 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         npc.behaviors.push(this.parseBehavior());
       } else if (this.check("STATE")) {
         npc.state = this.parseState();
-      } else {
-        const key = this.expectIdentifier();
-        this.expect("COLON");
-        const value = this.parseValue();
-        if (key === "type") npc.npcType = value;
-        else if (key === "model") npc.model = value;
-        else if (key === "dialogue_tree") npc.dialogueTree = value;
-        else npc.properties.push({ type: "NPCProperty", key, value });
-      }
-      this.skipNewlines();
-    }
-    this.expect("RBRACE");
-    this.popContext();
-    return npc;
-  }
-  parseBehavior() {
-    this.expect("BEHAVIOR");
-    const name = this.expectString();
-    this.expect("LBRACE");
-    this.skipNewlines();
-    const behavior = {
-      type: "Behavior",
-      name,
+      } else if (this.check("ACTION") || this.check("ASYNC")) {
+        const action = this.parseAction();
+        (npc.directives ?? (npc.directives = [])).push({
+          type: "method",
+          name: action.name,
+          parameters: action.parameters || [],
+          body: action.body,
+          async: action.async
+        });
+      } else if (this.check("IDENTIFIER") && this.current().value === "on" && this.peek(1).type === "IDENTIFIER") {
+        const eventName = this.peek(1).value;
+        this.advance();
+        this.advance();
+        while (this.check("DOT")) {
+          this.advance();
+          if (this.check("IDENTIFIER")) this.advance();
+        }
+        let parameters = [];
+        if (this.check("LPAREN")) {
+          parameters = this.parseParameterList();
+        }
+        this.skipBlock();
+        (npc.directives ?? (npc.directives = [])).push({
+          type: "lifecycle",
+          hook: eventName,
+          parameters,
+          body: []
+        });
+      } else if (this.check("AT")) {
+        this.advance();
+        const traitName = this.parseTraitName();
+        const config = this.parseOptionalTraitConfig(true);
+        (npc.traits ?? (npc.traits = [])).push({ type: "ObjectTrait", name: traitName, config });
+      } else {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        const value = this.parseValue();
+        if (key === "type") npc.npcType = value;
+        else if (key === "model") npc.model = value;
+        else if (key === "dialogue_tree") npc.dialogueTree = value;
+        else if (key === "position") {
+          if (Array.isArray(value) && value.length >= 3) {
+            npc.position = { x: value[0], y: value[1], z: value[2] };
+          } else if (value && typeof value === "object" && "x" in value) {
+            const v = value;
+            npc.position = { x: v.x, y: v.y, z: v.z };
+          }
+        } else if (key === "brain_ref") {
+          npc.brain = {
+            ...npc.brain ?? { type: "AgentBrainAttachment", brainType: "llm" },
+            type: "AgentBrainAttachment",
+            brainType: npc.brain?.brainType ?? "llm",
+            brainRef: value
+          };
+        } else if (key === "brain") {
+          const cfg = value && typeof value === "object" ? value : {};
+          npc.brain = {
+            type: "AgentBrainAttachment",
+            brainType: cfg.type ?? "llm",
+            autonomy: cfg.autonomy,
+            brainRef: typeof cfg.ref === "string" ? cfg.ref : typeof cfg.brainRef === "string" ? cfg.brainRef : void 0,
+            toolPermissions: Array.isArray(cfg.tools) ? cfg.tools.map(String) : void 0,
+            model: cfg.model && typeof cfg.model === "object" ? cfg.model : void 0
+          };
+        } else npc.properties.push({ type: "NPCProperty", key, value });
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return npc;
+  }
+  parseBehavior() {
+    this.expect("BEHAVIOR");
+    const name = this.expectString();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const behavior = {
+      type: "Behavior",
+      name,
       trigger: "idle",
       actions: []
     };
@@ -4349,7 +4885,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       options: []
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
       const key = this.expectIdentifier();
       this.expect("COLON");
@@ -4379,7 +4915,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         text: ""
       };
       while (!this.check("RBRACE") && !this.isAtEnd()) {
-        this.skipNewlines();
+        this.skipBlockMemberSeparators();
         if (this.check("RBRACE")) break;
         const key = this.expectIdentifier();
         this.expect("COLON");
@@ -4402,9 +4938,12 @@ var _HoloCompositionParser = class _HoloCompositionParser {
   // BRITTNEY AI FEATURES - STATE MACHINES
   // ===========================================================================
   parseStateMachine() {
-    this.currentLocation();
+    const startLoc = this.currentLocation();
     this.expect("STATE_MACHINE");
-    const name = this.expectString();
+    const name = this.parseOptionalStateMachineName("");
+    if (!name) {
+      this.error("Expected state_machine name");
+    }
     this.pushContext(`StateMachine "${name}"`);
     this.expect("LBRACE");
     this.skipNewlines();
@@ -4412,11 +4951,19 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       type: "StateMachine",
       name,
       initialState: "",
-      states: {}
+      inputs: [],
+      listeners: [],
+      states: {},
+      transitions: []
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
       this.skipNewlines();
       if (this.check("RBRACE")) break;
+      if (this.isAnimationTransitionShorthandStart()) {
+        sm.transitions.push(this.parseAnimationTransitionShorthand());
+        this.skipNewlines();
+        continue;
+      }
       if (this.check("STATE")) {
         this.advance();
         const stateName = this.check("STRING") || this.check("IDENTIFIER") ? this.advance().value : "anonymous";
@@ -4433,6 +4980,12 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           while (!this.check("RBRACE") && !this.isAtEnd()) {
             this.skipNewlines();
             if (this.check("RBRACE")) break;
+            if (this.current().type !== "IDENTIFIER" && !this.isKeywordAsIdentifierType(this.current().type)) {
+              if (this.check("LPAREN")) this.skipParens();
+              else if (this.check("LBRACE")) this.skipBlock();
+              else this.advance();
+              continue;
+            }
             const key2 = this.expectIdentifier();
             if (this.check("COLON")) {
               this.advance();
@@ -4448,7 +5001,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
                 this.expect("RBRACE");
               } else if (key2 === "actions") {
                 state.actions = this.parseBehaviorActions();
-              } else if (key2 === "transitions") {
+              } else if (this.parseAnimationStateMetadata(state, key2)) ; else if (key2 === "transitions") {
                 state.transitions = this.parseStateTransitions();
               } else if (key2 === "onDamage") {
                 state.onDamage = this.parseStatementBlock();
@@ -4457,7 +5010,11 @@ var _HoloCompositionParser = class _HoloCompositionParser {
               } else if (key2 === "onTimeout") {
                 state.onTimeout = this.parseStatementBlock();
               } else {
-                this.parseValue();
+                if (!this.check("RBRACE") && !this.isAtEnd()) {
+                  this.parseValue();
+                  if (this.check("LPAREN")) this.skipParens();
+                  if (this.check("LBRACE")) this.skipBlock();
+                }
               }
             } else if (this.check("LBRACE")) {
               if (key2 === "enter" || key2 === "entry") {
@@ -4473,6 +5030,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
               } else {
                 this.skipBlock();
               }
+            } else if (this.check("LPAREN")) {
+              this.skipParens();
+              if (this.check("LBRACE")) this.skipBlock();
             }
             this.skipNewlines();
           }
@@ -4482,18 +5042,37 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         this.skipNewlines();
         continue;
       }
+      if (this.current().type !== "IDENTIFIER" && !this.isKeywordAsIdentifierType(this.current().type)) {
+        if (this.check("LPAREN")) this.skipParens();
+        else if (this.check("LBRACE")) this.skipBlock();
+        else this.advance();
+        this.skipNewlines();
+        continue;
+      }
       const key = this.expectIdentifier();
       if (key === "initial" || key === "initialState") {
         this.expect("COLON");
         sm.initialState = this.parseValue();
+      } else if (key === "input") {
+        sm.inputs.push(this.parseAnimationInputDeclaration(startLoc));
+      } else if (key === "listen") {
+        sm.listeners.push(this.parseAnimationListenerDeclaration(startLoc));
       } else if (key === "states" && this.check("COLON")) {
         this.advance();
         sm.states = this.parseStateMachineStates();
+      } else if (key === "transitions" && this.check("COLON")) {
+        this.advance();
+        sm.transitions = this.parseStateTransitions();
       } else if (this.check("COLON")) {
         this.advance();
         this.parseValue();
+        if (this.check("LPAREN")) this.skipParens();
+        if (this.check("LBRACE")) this.skipBlock();
       } else if (this.check("LBRACE")) {
         this.skipBlock();
+      } else if (this.check("LPAREN")) {
+        this.skipParens();
+        if (this.check("LBRACE")) this.skipBlock();
       }
       this.skipNewlines();
     }
@@ -4514,19 +5093,27 @@ var _HoloCompositionParser = class _HoloCompositionParser {
    * Without this, @state_machine blocks were stored as opaque traits and
    * invisible to compile_to_a2a_agent_card and other compilers.
    */
-  parseStateMachineFromDecorator() {
+  parseStateMachineFromDecorator(name = "implicit") {
     const startLoc = this.currentLocation();
     this.expect("LBRACE");
     this.skipNewlines();
     const sm = {
       type: "StateMachine",
-      name: "implicit",
+      name,
       initialState: "",
-      states: {}
+      inputs: [],
+      listeners: [],
+      states: {},
+      transitions: []
     };
     while (!this.check("RBRACE") && !this.isAtEnd()) {
       this.skipNewlines();
       if (this.check("RBRACE")) break;
+      if (this.isAnimationTransitionShorthandStart()) {
+        sm.transitions.push(this.parseAnimationTransitionShorthand());
+        this.skipNewlines();
+        continue;
+      }
       if (this.check("STATE")) {
         this.advance();
         const stateName = this.check("STRING") || this.check("IDENTIFIER") ? this.advance().value : "anonymous";
@@ -4543,6 +5130,12 @@ var _HoloCompositionParser = class _HoloCompositionParser {
           while (!this.check("RBRACE") && !this.isAtEnd()) {
             this.skipNewlines();
             if (this.check("RBRACE")) break;
+            if (this.current().type !== "IDENTIFIER" && !this.isKeywordAsIdentifierType(this.current().type)) {
+              if (this.check("LPAREN")) this.skipParens();
+              else if (this.check("LBRACE")) this.skipBlock();
+              else this.advance();
+              continue;
+            }
             const key2 = this.expectIdentifier();
             if (this.check("COLON")) {
               this.advance();
@@ -4558,12 +5151,16 @@ var _HoloCompositionParser = class _HoloCompositionParser {
                 this.expect("RBRACE");
               } else if (key2 === "actions") {
                 state.actions = this.parseBehaviorActions();
-              } else if (key2 === "transitions") {
+              } else if (this.parseAnimationStateMetadata(state, key2)) ; else if (key2 === "transitions") {
                 state.transitions = this.parseStateTransitions();
               } else if (key2 === "timeout") {
                 state.timeout = this.parseValue();
               } else {
-                this.parseValue();
+                if (!this.check("RBRACE") && !this.isAtEnd()) {
+                  this.parseValue();
+                  if (this.check("LPAREN")) this.skipParens();
+                  if (this.check("LBRACE")) this.skipBlock();
+                }
               }
             } else if (this.check("LBRACE")) {
               if (key2 === "enter" || key2 === "entry" || key2 === "on_entry") {
@@ -4581,6 +5178,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
               } else {
                 this.skipBlock();
               }
+            } else if (this.check("LPAREN")) {
+              this.skipParens();
+              if (this.check("LBRACE")) this.skipBlock();
             }
             this.skipNewlines();
           }
@@ -4590,21 +5190,40 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         this.skipNewlines();
         continue;
       }
+      if (this.current().type !== "IDENTIFIER" && !this.isKeywordAsIdentifierType(this.current().type)) {
+        if (this.check("LPAREN")) this.skipParens();
+        else if (this.check("LBRACE")) this.skipBlock();
+        else this.advance();
+        this.skipNewlines();
+        continue;
+      }
       const key = this.expectIdentifier();
       if (key === "initial" || key === "initialState") {
         this.expect("COLON");
         sm.initialState = this.parseValue();
+      } else if (key === "input") {
+        sm.inputs.push(this.parseAnimationInputDeclaration(startLoc));
+      } else if (key === "listen") {
+        sm.listeners.push(this.parseAnimationListenerDeclaration(startLoc));
       } else if (key === "name") {
         this.expect("COLON");
         sm.name = this.parseValue();
       } else if (key === "states" && this.check("COLON")) {
         this.advance();
         sm.states = this.parseStateMachineStates();
+      } else if (key === "transitions" && this.check("COLON")) {
+        this.advance();
+        sm.transitions = this.parseStateTransitions();
       } else if (this.check("COLON")) {
         this.advance();
         this.parseValue();
+        if (this.check("LPAREN")) this.skipParens();
+        if (this.check("LBRACE")) this.skipBlock();
       } else if (this.check("LBRACE")) {
         this.skipBlock();
+      } else if (this.check("LPAREN")) {
+        this.skipParens();
+        if (this.check("LBRACE")) this.skipBlock();
       }
       this.skipNewlines();
     }
@@ -4637,7 +5256,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         if (key === "entry") state.entry = this.parseStatementBlock();
         else if (key === "exit") state.exit = this.parseStatementBlock();
         else if (key === "actions") state.actions = this.parseBehaviorActions();
-        else if (key === "onDamage") state.onDamage = this.parseStatementBlock();
+        else if (this.parseAnimationStateMetadata(state, key)) ; else if (key === "onDamage") state.onDamage = this.parseStatementBlock();
         else if (key === "timeout") state.timeout = this.parseValue();
         else if (key === "onTimeout") state.onTimeout = this.parseStatementBlock();
         else if (key === "transitions") state.transitions = this.parseStateTransitions();
@@ -4651,13 +5270,385 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     this.expect("RBRACE");
     return states;
   }
+  parseOptionalStateMachineName(defaultName) {
+    if (this.check("STRING") || this.check("IDENTIFIER") || this.isKeywordAsIdentifier()) {
+      return this.advance().value;
+    }
+    return defaultName;
+  }
+  parseAnimationStateMetadata(state, key) {
+    if (key === "clip") {
+      state.clip = String(this.parseValue() ?? "");
+      return true;
+    }
+    if (key === "clips") {
+      state.clips = this.coerceStringArray(this.parseValue());
+      return true;
+    }
+    if (key === "parameter") {
+      state.parameter = String(this.parseValue() ?? "");
+      return true;
+    }
+    if (key === "parameters") {
+      state.parameters = this.coerceStringArray(this.parseValue());
+      return true;
+    }
+    if (key === "thresholds") {
+      state.thresholds = this.coerceNumberArray(this.parseValue());
+      return true;
+    }
+    if (key === "blendType" || key === "blend_type" || key === "blend") {
+      const blendType = String(this.parseValue() ?? "").toLowerCase();
+      if (blendType === "1d" || blendType === "direct") {
+        state.blendType = blendType;
+      } else {
+        this.error(`Unknown animation blend type "${blendType}"`);
+      }
+      return true;
+    }
+    if (key === "blendMode" || key === "blend_mode") {
+      const blendMode = String(this.parseValue() ?? "").toLowerCase();
+      if (blendMode === "override" || blendMode === "additive") {
+        state.blendMode = blendMode;
+      } else {
+        this.error(`Unknown animation blend mode "${blendMode}"`);
+      }
+      return true;
+    }
+    if (key === "mask") {
+      state.mask = this.coerceStringArray(this.parseValue());
+      return true;
+    }
+    if (key === "baseline") {
+      state.baseline = this.coerceNumberRecord(this.parseValue());
+      return true;
+    }
+    return false;
+  }
+  coerceStringArray(value) {
+    if (!Array.isArray(value)) return value == null ? [] : [String(value)];
+    return value.map((entry) => String(entry));
+  }
+  coerceNumberArray(value) {
+    if (!Array.isArray(value)) {
+      const single = Number(value);
+      return Number.isFinite(single) ? [single] : [];
+    }
+    return value.map((entry) => Number(entry)).filter((entry) => Number.isFinite(entry));
+  }
+  coerceNumberRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+      const numeric = Number(raw);
+      if (Number.isFinite(numeric)) out[key] = numeric;
+    }
+    return out;
+  }
+  isStateNameToken(offset = 0) {
+    const token = this.peek(offset);
+    return token.type === "STRING" || token.type === "IDENTIFIER" || this.isKeywordAsIdentifierType(token.type);
+  }
+  isAnimationTransitionShorthandStart() {
+    if (!this.isStateNameToken()) return false;
+    return this.peek(1).type === "ARROW" || this.peek(1).type === "MINUS" && this.peek(2).type === "GREATER";
+  }
+  consumeStateTransitionArrow() {
+    if (this.match("ARROW")) return true;
+    if (this.check("MINUS") && this.peek(1).type === "GREATER") {
+      this.advance();
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  parseAnimationInputDeclaration(startLoc) {
+    const name = this.expectIdentifier();
+    this.expect("COLON");
+    const rawType = this.parseIdentifierOrStringValue();
+    const inputType = this.normalizeAnimationInputType(rawType);
+    let defaultValue;
+    if (this.match("EQUALS")) {
+      defaultValue = this.coerceAnimationInputDefault(inputType, this.parseValue());
+    }
+    return {
+      type: "AnimationInput",
+      name,
+      inputType,
+      rawType,
+      default: defaultValue,
+      loc: { start: startLoc, end: this.currentLocation() }
+    };
+  }
+  parseAnimationListenerDeclaration(startLoc) {
+    const event = this.parseDottedIdentifierValue("Expected listener event");
+    if (!this.consumeStateTransitionArrow()) {
+      this.error("Expected -> in animation listener");
+    }
+    if (this.isIdentifierValue("fire")) {
+      this.advance();
+      return {
+        type: "AnimationListener",
+        event,
+        parameter: this.parseDottedIdentifierValue("Expected trigger input"),
+        action: "fire",
+        loc: { start: startLoc, end: this.currentLocation() }
+      };
+    }
+    if (this.isIdentifierValue("reset")) {
+      this.advance();
+      return {
+        type: "AnimationListener",
+        event,
+        parameter: this.parseDottedIdentifierValue("Expected trigger input"),
+        action: "reset",
+        loc: { start: startLoc, end: this.currentLocation() }
+      };
+    }
+    const parameter = this.parseDottedIdentifierValue("Expected animation input");
+    this.expect("EQUALS");
+    const assignment = this.parseAnimationListenerValue();
+    return {
+      type: "AnimationListener",
+      event,
+      parameter,
+      action: "set",
+      ...assignment,
+      loc: { start: startLoc, end: this.currentLocation() }
+    };
+  }
+  parseAnimationListenerValue() {
+    if (this.isIdentifierValue("event")) {
+      return { source: this.parseDottedIdentifierValue("Expected event value source") };
+    }
+    const value = this.parseValue();
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+      return { value };
+    }
+    return { value: String(value ?? "") };
+  }
+  normalizeAnimationInputType(rawType) {
+    const normalized = rawType.toLowerCase();
+    if (normalized === "number") return "float";
+    if (normalized === "boolean") return "bool";
+    if (normalized === "bool" || normalized === "float" || normalized === "int" || normalized === "trigger") {
+      return normalized;
+    }
+    this.error(`Unknown animation input type "${rawType}", defaulting to float`);
+    return "float";
+  }
+  coerceAnimationInputDefault(inputType, value) {
+    if (inputType === "bool" || inputType === "trigger") return Boolean(value);
+    if (typeof value === "number") return value;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    return void 0;
+  }
+  parseAnimationTransitionShorthand() {
+    const startLoc = this.currentLocation();
+    const rawFrom = this.parseStateNameValue();
+    const from = rawFrom.toLowerCase() === "any" ? "any" : rawFrom;
+    if (!this.consumeStateTransitionArrow()) {
+      this.error("Expected -> in animation transition");
+    }
+    const target = this.parseStateNameValue();
+    const transition = {
+      type: "StateTransition",
+      from,
+      target,
+      conditions: [],
+      loc: { start: startLoc, end: this.currentLocation() }
+    };
+    while (!this.check("NEWLINE") && !this.check("SEMICOLON") && !this.check("COMMA") && !this.check("RBRACE") && !this.isAtEnd()) {
+      if (!this.isStateNameToken()) break;
+      const clause = this.current().value.toLowerCase();
+      this.advance();
+      if (clause === "when") {
+        transition.condition = this.parseExpression();
+        transition.conditions = this.expressionToAnimationConditions(transition.condition);
+      } else if (clause === "on") {
+        const event = this.parseIdentifierOrStringValue();
+        transition.event = event;
+        transition.conditions = [
+          {
+            type: "AnimationTransitionCondition",
+            parameter: event,
+            operator: "==",
+            value: true,
+            loc: { start: startLoc, end: this.currentLocation() }
+          }
+        ];
+      } else if (clause === "over" || clause === "duration") {
+        transition.duration = this.parseNumberClauseValue();
+      } else if (clause === "easing") {
+        transition.easing = this.parseIdentifierOrStringValue();
+      } else if (clause === "exittime" || clause === "exit_time") {
+        transition.exitTime = this.parseNumberClauseValue();
+        transition.hasExitTime = true;
+      } else if (clause === "pausewhenexiting" || clause === "pause_when_exiting") {
+        transition.pauseWhenExiting = this.parseOptionalBooleanFlag();
+      } else if (clause === "priority") {
+        transition.priority = this.parseNumberClauseValue();
+      } else if (clause === "cantransitiontoself" || clause === "can_transition_to_self") {
+        transition.canTransitionToSelf = this.parseOptionalBooleanFlag();
+      } else {
+        this.error(`Unknown animation transition clause "${clause}"`);
+        break;
+      }
+    }
+    transition.loc = { start: startLoc, end: this.currentLocation() };
+    if (this.check("COMMA") || this.check("SEMICOLON")) this.advance();
+    return transition;
+  }
+  parseStateNameValue() {
+    if (this.check("STRING") || this.check("IDENTIFIER") || this.isKeywordAsIdentifier()) {
+      return this.advance().value;
+    }
+    this.error(`Expected state name, got ${this.current().type}`);
+    return this.isAtEnd() ? "" : this.advance().value;
+  }
+  parseNumberClauseValue() {
+    if (this.check("COLON")) this.advance();
+    const value = this.parseValue();
+    return typeof value === "number" ? value : Number(value) || 0;
+  }
+  parseIdentifierOrStringValue() {
+    if (this.check("COLON")) this.advance();
+    if (this.check("STRING") || this.check("IDENTIFIER") || this.isKeywordAsIdentifier()) {
+      return this.advance().value;
+    }
+    const value = this.parseValue();
+    return value == null ? "" : String(value);
+  }
+  parseDottedIdentifierValue(message) {
+    let value = this.parseIdentifierOrStringValue();
+    if (!value) {
+      this.error(message);
+    }
+    while (this.check("DOT")) {
+      this.advance();
+      const part = this.parseIdentifierOrStringValue();
+      if (!part) {
+        this.error("Expected property name after dot");
+        break;
+      }
+      value += `.${part}`;
+    }
+    return value;
+  }
+  isIdentifierValue(value) {
+    return (this.current().type === "IDENTIFIER" || this.isKeywordAsIdentifierType(this.current().type)) && this.current().value === value;
+  }
+  parseOptionalBooleanFlag() {
+    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;
+  }
+  expressionToAnimationConditions(expression) {
+    if (expression.type === "BinaryExpression" && (expression.operator === "&&" || expression.operator === "||")) {
+      const left = this.expressionToAnimationConditions(expression.left);
+      const right = this.expressionToAnimationConditions(expression.right);
+      if (left.length > 0 && right.length > 0) {
+        left[left.length - 1].chain = expression.operator === "||" ? "or" : "and";
+      }
+      return [...left, ...right];
+    }
+    const comparison = this.expressionToAnimationCondition(expression);
+    return comparison ? [comparison] : [];
+  }
+  expressionToAnimationCondition(expression) {
+    const startLoc = expression.loc?.start ?? this.currentLocation();
+    const endLoc = expression.loc?.end ?? this.currentLocation();
+    if (expression.type === "BinaryExpression") {
+      const normalizedOperator = this.normalizeAnimationConditionOperator(expression.operator);
+      if (normalizedOperator) {
+        const parameter = this.expressionToString(expression.left);
+        if (parameter) {
+          return {
+            type: "AnimationTransitionCondition",
+            parameter,
+            operator: normalizedOperator,
+            value: this.expressionLiteralValue(expression.right),
+            loc: { start: startLoc, end: endLoc }
+          };
+        }
+      }
+    }
+    if (expression.type === "Identifier" || expression.type === "MemberExpression") {
+      return {
+        type: "AnimationTransitionCondition",
+        parameter: this.expressionToString(expression),
+        operator: "==",
+        value: true,
+        loc: { start: startLoc, end: endLoc }
+      };
+    }
+    if (expression.type === "UnaryExpression" && expression.operator === "!") {
+      const parameter = this.expressionToString(expression.argument);
+      if (parameter) {
+        return {
+          type: "AnimationTransitionCondition",
+          parameter,
+          operator: "==",
+          value: false,
+          loc: { start: startLoc, end: endLoc }
+        };
+      }
+    }
+    return null;
+  }
+  normalizeAnimationConditionOperator(operator) {
+    if (operator === "===") return "==";
+    if (operator === "!==") return "!=";
+    if (operator === "==" || operator === "!=" || operator === ">" || operator === "<" || operator === ">=" || operator === "<=") {
+      return operator;
+    }
+    return null;
+  }
+  expressionLiteralValue(expression) {
+    if (expression.type === "Literal") {
+      if (expression.value === null) return "null";
+      return expression.value;
+    }
+    const value = this.expressionToString(expression);
+    return value || "";
+  }
   parseStateTransitions() {
+    if (this.check("LBRACE")) {
+      this.expect("LBRACE");
+      this.skipNewlines();
+      const transitions2 = [];
+      while (!this.check("RBRACE") && !this.isAtEnd()) {
+        this.skipNewlines();
+        if (this.check("RBRACE")) break;
+        if (this.isAnimationTransitionShorthandStart()) {
+          transitions2.push(this.parseAnimationTransitionShorthand());
+        } else {
+          this.error(`Expected animation transition, got ${this.current().type}`);
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("RBRACE");
+      return transitions2;
+    }
     this.expect("LBRACKET");
     this.skipNewlines();
     const transitions = [];
     while (!this.check("RBRACKET") && !this.isAtEnd()) {
       this.skipNewlines();
       if (this.check("RBRACKET")) break;
+      if (this.isAnimationTransitionShorthandStart()) {
+        transitions.push(this.parseAnimationTransitionShorthand());
+        this.skipNewlines();
+        continue;
+      }
       this.expect("LBRACE");
       this.skipNewlines();
       const transition = {
@@ -4669,9 +5660,46 @@ var _HoloCompositionParser = class _HoloCompositionParser {
         if (this.check("RBRACE")) break;
         const key = this.expectIdentifier();
         this.expect("COLON");
-        if (key === "target") transition.target = this.parseValue();
-        else if (key === "condition") transition.condition = this.parseExpression();
-        else if (key === "event") transition.event = this.parseValue();
+        if (key === "from") {
+          const from = this.parseValue();
+          transition.from = from.toLowerCase() === "any" ? "any" : from;
+        } else if (key === "target" || key === "to") {
+          transition.target = this.parseValue();
+        } else if (key === "condition" || key === "when") {
+          transition.condition = this.parseExpression();
+          transition.conditions = this.expressionToAnimationConditions(transition.condition);
+        } else if (key === "event" || key === "on") {
+          transition.event = this.parseValue();
+          transition.conditions = [
+            {
+              type: "AnimationTransitionCondition",
+              parameter: transition.event,
+              operator: "==",
+              value: true,
+              loc: transition.loc
+            }
+          ];
+        } else if (key === "duration" || key === "over") {
+          const duration = this.parseValue();
+          transition.duration = typeof duration === "number" ? duration : Number(duration) || 0;
+        } else if (key === "easing") {
+          transition.easing = this.parseValue();
+        } else if (key === "exitTime" || key === "exit_time") {
+          const exitTime = this.parseValue();
+          transition.exitTime = typeof exitTime === "number" ? exitTime : Number(exitTime) || 0;
+          transition.hasExitTime = true;
+        } else if (key === "hasExitTime" || key === "has_exit_time") {
+          transition.hasExitTime = Boolean(this.parseValue());
+        } else if (key === "pauseWhenExiting" || key === "pause_when_exiting") {
+          transition.pauseWhenExiting = Boolean(this.parseValue());
+        } else if (key === "priority") {
+          const priority = this.parseValue();
+          transition.priority = typeof priority === "number" ? priority : Number(priority) || 0;
+        } else if (key === "canTransitionToSelf" || key === "can_transition_to_self") {
+          transition.canTransitionToSelf = Boolean(this.parseValue());
+        } else {
+          this.parseValue();
+        }
         this.skipNewlines();
       }
       this.expect("RBRACE");
@@ -4961,32 +5989,714 @@ var _HoloCompositionParser = class _HoloCompositionParser {
   isDomainBlockToken() {
     return _HoloCompositionParser.DOMAIN_TOKENS.has(this.current().type);
   }
-  // ===========================================================================
-  // NORM LIFECYCLE BLOCKS (v4.5 — March 2026, CRSEC Model)
-  // ===========================================================================
-  /**
-   * Parse a norm block with full CRSEC lifecycle sub-blocks.
-   *
-   * Pattern:
-   * ```
-   * norm "NormName" @trait1 @trait2 {
-   *   description: "..."
-   *   category: "..."
-   *   priority: 8
-   *
-   *   creation { ... }
-   *   representation { ... }
-   *   spreading { ... }
-   *   evaluation { ... }
-   *   compliance { ... }
-   *
-   *   on norm_violated(agent, context) { ... }
-   * }
-   * ```
-   */
-  parseNormBlock() {
-    const startLoc = this.currentLocation();
-    this.pushContext("norm");
+  isLooseOnHandlerStart() {
+    return this.check("IDENTIFIER") && this.current().value === "on";
+  }
+  skipLooseOnHandler() {
+    if (!this.isLooseOnHandlerStart()) return;
+    this.advance();
+    while (!this.check("LBRACE") && !this.isAtEnd()) {
+      if (this.check("LPAREN")) {
+        this.skipParens();
+      } else {
+        this.advance();
+      }
+    }
+    if (this.check("LBRACE")) {
+      this.skipBlock();
+    }
+  }
+  isLooseDomainBlockStart() {
+    if (!this.check("IDENTIFIER")) return false;
+    const keyword = this.current().value;
+    if (!/_material$/i.test(keyword)) return false;
+    let index = this.pos + 1;
+    if (this.tokens[index]?.type === "STRING" || this.tokens[index]?.type === "IDENTIFIER") {
+      index++;
+    }
+    while (this.tokens[index]?.type === "AT") {
+      index += 2;
+      if (this.tokens[index]?.type === "LPAREN") {
+        let depth = 1;
+        index++;
+        while (depth > 0 && index < this.tokens.length) {
+          if (this.tokens[index].type === "LPAREN") depth++;
+          else if (this.tokens[index].type === "RPAREN") depth--;
+          index++;
+        }
+      }
+    }
+    while (this.tokens[index]?.type === "NEWLINE") index++;
+    return this.tokens[index]?.type === "LBRACE";
+  }
+  isLooseNamedDomainBlockStart() {
+    if (!this.check("IDENTIFIER")) return false;
+    const keyword = this.current().value.toLowerCase();
+    if (this.isPrimitiveShape(keyword) || this.isLightPrimitive(keyword) || keyword === "on") {
+      return false;
+    }
+    let index = this.pos + 1;
+    if (this.tokens[index]?.type !== "STRING" && this.tokens[index]?.type !== "IDENTIFIER") {
+      return false;
+    }
+    index++;
+    while (this.tokens[index]?.type === "AT") {
+      index += 2;
+      if (this.tokens[index]?.type === "LPAREN") {
+        let depth = 1;
+        index++;
+        while (depth > 0 && index < this.tokens.length) {
+          if (this.tokens[index].type === "LPAREN") depth++;
+          else if (this.tokens[index].type === "RPAREN") depth--;
+          index++;
+        }
+      }
+    }
+    while (this.tokens[index]?.type === "NEWLINE") index++;
+    return this.tokens[index]?.type === "LBRACE";
+  }
+  // ===========================================================================
+  // MMO/AAA GAME CONSTRUCTS (v6.2 — June 2026)
+  // ===========================================================================
+  /**
+   * Parse a loot_table block with weighted entry sub-blocks and optional
+   * guaranteed drop section.
+   *
+   * Syntax:
+   *   loot_table goblin_drops {
+   *     entry common_coin { item: "gold_coin" qty: "1..5" weight: 60 }
+   *     entry nothing     { weight: 10 }
+   *     guaranteed { item: "goblin_ear" qty: 1 }
+   *     multiplier_on_faction_hostile: "ironveil * 1.5"
+   *   }
+   */
+  parseLootTable() {
+    const startLoc = this.currentLocation();
+    this.pushContext("loot-table");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const entries = [];
+    let guaranteed;
+    const properties = {};
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "entry") {
+        this.advance();
+        const entryId = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+        const entryProps = {};
+        let weight = 0;
+        let itemId;
+        let qty;
+        let rarity;
+        let condition;
+        if (this.check("LBRACE")) {
+          this.advance();
+          this.skipNewlines();
+          while (!this.check("RBRACE") && !this.isAtEnd()) {
+            this.skipNewlines();
+            if (this.check("RBRACE")) break;
+            const key = this.expectIdentifier();
+            this.expect("COLON");
+            const val = this.parseValue();
+            if (key === "item") itemId = val;
+            else if (key === "weight") weight = val;
+            else if (key === "qty") qty = val;
+            else if (key === "rarity") rarity = val;
+            else if (key === "condition") condition = val;
+            else entryProps[key] = val;
+            if (this.check("COMMA")) this.advance();
+            this.skipNewlines();
+          }
+          this.expect("RBRACE");
+        }
+        entries.push({
+          type: "LootEntry",
+          id: entryId,
+          itemId,
+          weight,
+          qty,
+          rarity,
+          condition,
+          properties: entryProps
+        });
+      } else if (this.check("IDENTIFIER") && this.current().value === "guaranteed") {
+        this.advance();
+        if (this.check("LBRACE")) {
+          this.advance();
+          this.skipNewlines();
+          guaranteed = {};
+          while (!this.check("RBRACE") && !this.isAtEnd()) {
+            this.skipNewlines();
+            if (this.check("RBRACE")) break;
+            const key = this.expectIdentifier();
+            this.expect("COLON");
+            guaranteed[key] = this.parseValue();
+            if (this.check("COMMA")) this.advance();
+            this.skipNewlines();
+          }
+          this.expect("RBRACE");
+        }
+      } else {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        properties[key] = this.parseValue();
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "LootTable",
+      name,
+      entries,
+      guaranteed,
+      properties
+    };
+  }
+  /**
+   * Parse a world_chunk block for open-world streaming.
+   *
+   * Syntax:
+   *   world_chunk dockside {
+   *     bounds: ((-200, 0, -200), (200, 100, 200))
+   *     priority: "high"
+   *     lod_distances: [50, 150, 400]
+   *     biome: "coastal_urban"
+   *     npc_roster: ["merchant_alva", "harbor_guard_01"]
+   *     streaming { load_radius: 300 unload_radius: 500 budget_kb: 32768 }
+   *   }
+   */
+  parseWorldChunk() {
+    const startLoc = this.currentLocation();
+    this.pushContext("world-chunk");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let priority;
+    let biome;
+    let lodDistances;
+    let assetManifest;
+    let npcRoster;
+    let spawnPoints;
+    let streaming;
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "streaming") {
+        this.advance();
+        if (this.check("LBRACE")) {
+          this.advance();
+          this.skipNewlines();
+          streaming = {};
+          while (!this.check("RBRACE") && !this.isAtEnd()) {
+            this.skipNewlines();
+            if (this.check("RBRACE")) break;
+            const key = this.expectIdentifier();
+            this.expect("COLON");
+            streaming[key] = this.parseValue();
+            if (this.check("COMMA")) this.advance();
+            this.skipNewlines();
+          }
+          this.expect("RBRACE");
+        }
+      } else if (this.check("IDENTIFIER") && this.current().value === "asset_manifest") {
+        this.advance();
+        const val = this.parseValue();
+        assetManifest = Array.isArray(val) ? val : [val];
+      } else {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        const val = this.parseValue();
+        if (key === "priority") priority = val;
+        else if (key === "biome") biome = val;
+        else if (key === "lod_distances")
+          lodDistances = Array.isArray(val) ? val : [val];
+        else if (key === "npc_roster") npcRoster = Array.isArray(val) ? val : [val];
+        else if (key === "spawn_points") spawnPoints = val;
+        else properties[key] = val;
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "WorldChunk",
+      name,
+      priority,
+      biome,
+      lodDistances,
+      assetManifest,
+      npcRoster,
+      spawnPoints,
+      streaming,
+      properties
+    };
+  }
+  /**
+   * Parse a world_layer block (P2.4 — phasing).
+   *
+   * Syntax:
+   *   world_layer post_awakening {
+   *     requires_quest: "main_chapter_1"   // visible AFTER the quest is done
+   *     npcs: ["restored_keeper"]          // forbids_quest = visible BEFORE
+   *     objects: ["healed_shrine"]
+   *   }
+   */
+  parseWorldLayer() {
+    const startLoc = this.currentLocation();
+    this.pushContext("world-layer");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let questId = "";
+    let mustBeCompleted = true;
+    let npcs = [];
+    let objects = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      this.expect("COLON");
+      const val = this.parseValue();
+      if (key === "requires_quest") {
+        questId = String(val);
+        mustBeCompleted = true;
+      } else if (key === "forbids_quest") {
+        questId = String(val);
+        mustBeCompleted = false;
+      } else if (key === "npcs") {
+        npcs = (Array.isArray(val) ? val : [val]).map((v) => String(v));
+      } else if (key === "objects") {
+        objects = (Array.isArray(val) ? val : [val]).map((v) => String(v));
+      } else {
+        properties[key] = val;
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "WorldLayer",
+      name,
+      predicate: { type: "PhasePredicate", kind: "quest_flag", questId, mustBeCompleted },
+      npcs,
+      objects,
+      properties
+    };
+  }
+  /**
+   * Parse a dungeon_instance block (P2.6 — instanced content).
+   *
+   * Syntax:
+   *   dungeon_instance shadowfen_keep {
+   *     max_instances: 10
+   *     party_size: 5
+   *     reset_timer: 3600
+   *     completion_quest: "shadowfen_cleared"
+   *     npcs: ["dungeon_boss"]
+   *   }
+   */
+  parseDungeonInstance() {
+    const startLoc = this.currentLocation();
+    this.pushContext("dungeon-instance");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let maxInstances = 1;
+    let partySize = 1;
+    let resetTimer = 0;
+    let completionQuest = "";
+    let npcs = [];
+    let objects = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      this.expect("COLON");
+      const val = this.parseValue();
+      if (key === "max_instances") maxInstances = Number(val) || 1;
+      else if (key === "party_size") partySize = Number(val) || 1;
+      else if (key === "reset_timer") resetTimer = Number(val) || 0;
+      else if (key === "completion_quest") completionQuest = String(val);
+      else if (key === "npcs") npcs = (Array.isArray(val) ? val : [val]).map((v) => String(v));
+      else if (key === "objects")
+        objects = (Array.isArray(val) ? val : [val]).map((v) => String(v));
+      else properties[key] = val;
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "DungeonInstance",
+      name,
+      maxInstances,
+      partySize,
+      resetTimer,
+      completionQuest,
+      npcs,
+      objects,
+      properties
+    };
+  }
+  /**
+   * Parse a world_shard block (P2.5 — world sharding).
+   *
+   * Syntax:
+   *   world_shard north_province {
+   *     min: [-1000, 0, -1000]
+   *     max: [0, 256, 1000]
+   *     neighbors: ["south_province"]
+   *     max_players: 200
+   *     handoff: "seamless"
+   *   }
+   */
+  parseWorldShard() {
+    const startLoc = this.currentLocation();
+    this.pushContext("world-shard");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let min = [0, 0, 0];
+    let max = [0, 0, 0];
+    let neighbors = [];
+    let maxPlayers = 100;
+    let handoff = "seamless";
+    const toVec3 = (val) => {
+      const a = (Array.isArray(val) ? val : [val]).map((v) => Number(v) || 0);
+      return [a[0] ?? 0, a[1] ?? 0, a[2] ?? 0];
+    };
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      this.expect("COLON");
+      const val = this.parseValue();
+      if (key === "min") min = toVec3(val);
+      else if (key === "max") max = toVec3(val);
+      else if (key === "neighbors")
+        neighbors = (Array.isArray(val) ? val : [val]).map((v) => String(v));
+      else if (key === "max_players") maxPlayers = Number(val) || 100;
+      else if (key === "handoff") handoff = String(val);
+      else properties[key] = val;
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "WorldShard",
+      name,
+      min,
+      max,
+      neighbors,
+      maxPlayers,
+      handoff,
+      properties
+    };
+  }
+  /**
+   * Parse a spawn_point block.
+   *
+   * Syntax:
+   *   spawn_point village_entry {
+   *     faction: "neutral"
+   *     max_count: 10
+   *     respawn_radius: 5
+   *     position: (10, 0, 10)
+   *   }
+   */
+  parseSpawnPoint() {
+    const startLoc = this.currentLocation();
+    this.pushContext("spawn-point");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let faction;
+    let maxCount;
+    let respawnRadius;
+    let position;
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      this.expect("COLON");
+      const val = this.parseValue();
+      if (key === "faction") faction = val;
+      else if (key === "max_count") maxCount = val;
+      else if (key === "respawn_radius") respawnRadius = val;
+      else if (key === "position") {
+        if (Array.isArray(val) && val.length >= 3) {
+          position = { x: val[0], y: val[1], z: val[2] };
+        }
+      } else {
+        properties[key] = val;
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "SpawnPoint",
+      name,
+      faction,
+      maxCount,
+      respawnRadius,
+      position,
+      properties
+    };
+  }
+  /**
+   * Parse a trigger block for MMO interaction volumes.
+   *
+   * Syntax:
+   *   trigger dungeon_entrance {
+   *     radius: 3
+   *     faction_filter: ["alliance", "neutral"]
+   *     on_enter { emit("dungeon_enter") }
+   *     on_exit  { emit("dungeon_exit")  }
+   *   }
+   */
+  parseGameTrigger() {
+    const startLoc = this.currentLocation();
+    this.pushContext("game-trigger");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let radius = 1;
+    let factionFilter;
+    let position;
+    const onEnter = [];
+    const onExit = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "on_enter") {
+        this.advance();
+        const params = this.check("LPAREN") ? this.parseParameterList() : [];
+        const body = this.check("LBRACE") ? (() => {
+          this.advance();
+          this.skipNewlines();
+          const stmts = this.parseStatementBlock();
+          this.expect("RBRACE");
+          return stmts;
+        })() : [];
+        onEnter.push({ type: "EventHandler", event: "on_enter", parameters: params, body });
+      } else if (this.check("IDENTIFIER") && this.current().value === "on_exit") {
+        this.advance();
+        const params = this.check("LPAREN") ? this.parseParameterList() : [];
+        const body = this.check("LBRACE") ? (() => {
+          this.advance();
+          this.skipNewlines();
+          const stmts = this.parseStatementBlock();
+          this.expect("RBRACE");
+          return stmts;
+        })() : [];
+        onExit.push({ type: "EventHandler", event: "on_exit", parameters: params, body });
+      } else {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        const val = this.parseValue();
+        if (key === "radius") radius = val;
+        else if (key === "faction_filter")
+          factionFilter = Array.isArray(val) ? val : [val];
+        else if (key === "position") {
+          if (Array.isArray(val) && val.length >= 3) {
+            position = { x: val[0], y: val[1], z: val[2] };
+          }
+        } else {
+          properties[key] = val;
+        }
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "GameTrigger",
+      name,
+      radius,
+      factionFilter,
+      onEnter: onEnter.length > 0 ? onEnter : void 0,
+      onExit: onExit.length > 0 ? onExit : void 0,
+      position,
+      properties
+    };
+  }
+  /**
+   * Parse a scene-level movement path:
+   *   movement_path patrol_route { mode: "patrol" loop: true speed: 2.5
+   *     waypoints: [[0,0,0],[10,0,0]] easing: "linear" }
+   */
+  parseMovementPath() {
+    const startLoc = this.currentLocation();
+    this.pushContext("movement-path");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let mode;
+    let loop;
+    let speed;
+    let waypoints;
+    let easing;
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      this.expect("COLON");
+      const val = this.parseValue();
+      if (key === "mode") mode = val;
+      else if (key === "loop") loop = val;
+      else if (key === "speed") speed = val;
+      else if (key === "waypoints") waypoints = val;
+      else if (key === "easing") easing = val;
+      else properties[key] = val;
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "MovementPath",
+      name,
+      mode,
+      loop,
+      speed,
+      waypoints,
+      easing,
+      properties
+    };
+  }
+  /**
+   * Parse a scene-level reaction trigger:
+   *   reaction_trigger on_player_enter { target: "player" condition: "..."
+   *     on_activate { emit("zone_entered") } on_deactivate { ... } cooldown: 2 }
+   */
+  parseReactionTrigger() {
+    const startLoc = this.currentLocation();
+    this.pushContext("reaction-trigger");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let target;
+    let condition;
+    let cooldown;
+    const onActivate = [];
+    const onDeactivate = [];
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "on_activate") {
+        this.advance();
+        const params = this.check("LPAREN") ? this.parseParameterList() : [];
+        const body = this.check("LBRACE") ? (() => {
+          this.advance();
+          this.skipNewlines();
+          const stmts = this.parseStatementBlock();
+          this.expect("RBRACE");
+          return stmts;
+        })() : [];
+        onActivate.push({ type: "EventHandler", event: "on_activate", parameters: params, body });
+      } else if (this.check("IDENTIFIER") && this.current().value === "on_deactivate") {
+        this.advance();
+        const params = this.check("LPAREN") ? this.parseParameterList() : [];
+        const body = this.check("LBRACE") ? (() => {
+          this.advance();
+          this.skipNewlines();
+          const stmts = this.parseStatementBlock();
+          this.expect("RBRACE");
+          return stmts;
+        })() : [];
+        onDeactivate.push({
+          type: "EventHandler",
+          event: "on_deactivate",
+          parameters: params,
+          body
+        });
+      } else {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        const val = this.parseValue();
+        if (key === "target") target = val;
+        else if (key === "condition") condition = val;
+        else if (key === "cooldown") cooldown = val;
+        else properties[key] = val;
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "ReactionTrigger",
+      name,
+      target,
+      condition,
+      cooldown,
+      onActivate: onActivate.length > 0 ? onActivate : void 0,
+      onDeactivate: onDeactivate.length > 0 ? onDeactivate : void 0,
+      properties
+    };
+  }
+  // ===========================================================================
+  // NORM LIFECYCLE BLOCKS (v4.5 — March 2026, CRSEC Model)
+  // ===========================================================================
+  /**
+   * Parse a norm block with full CRSEC lifecycle sub-blocks.
+   *
+   * Pattern:
+   * ```
+   * norm "NormName" @trait1 @trait2 {
+   *   description: "..."
+   *   category: "..."
+   *   priority: 8
+   *
+   *   creation { ... }
+   *   representation { ... }
+   *   spreading { ... }
+   *   evaluation { ... }
+   *   compliance { ... }
+   *
+   *   on norm_violated(agent, context) { ... }
+   * }
+   * ```
+   */
+  parseNormBlock() {
+    const startLoc = this.currentLocation();
+    this.pushContext("norm");
     this.advance();
     let name = "unnamed";
     if (this.check("STRING")) {
@@ -4994,15 +6704,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     } else if (this.check("IDENTIFIER")) {
       name = this.expectIdentifier();
     }
-    const traits = [];
-    while (this.check("AT") && this.peek(1)?.type === "IDENTIFIER") {
-      this.advance();
-      traits.push(this.current().value);
-      this.advance();
-      if (this.check("LPAREN")) {
-        this.skipParens();
-      }
-    }
+    const traits = this.parseInlineTraitNamesBeforeBlock();
     this.expect("LBRACE");
     this.skipNewlines();
     const properties = {};
@@ -5056,6 +6758,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             body
           });
         }
+      } else if (this.isPropertyName() && this.peek(1)?.type === "LBRACE") {
+        const key = this.parsePropertyKey();
+        properties[key] = this.parseBlockTraitConfig();
       } else if (this.check("IDENTIFIER") || this.check("STRING")) {
         const key = this.check("STRING") ? this.expectString() : this.expectIdentifier();
         this.expect("COLON");
@@ -5135,15 +6840,7 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     } else if (this.check("IDENTIFIER")) {
       name = this.expectIdentifier();
     }
-    const traits = [];
-    while (this.check("AT") && this.peek(1)?.type === "IDENTIFIER") {
-      this.advance();
-      traits.push(this.current().value);
-      this.advance();
-      if (this.check("LPAREN")) {
-        this.skipParens();
-      }
-    }
+    const traits = this.parseInlineTraitNamesBeforeBlock();
     this.expect("LBRACE");
     this.skipNewlines();
     const properties = {};
@@ -5185,6 +6882,9 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             body
           });
         }
+      } else if (this.isPropertyName() && this.peek(1)?.type === "LBRACE") {
+        const key = this.parsePropertyKey();
+        properties[key] = this.parseBlockTraitConfig();
       } else if (this.check("IDENTIFIER") || this.check("STRING")) {
         const key = this.check("STRING") ? this.expectString() : this.expectIdentifier();
         this.expect("COLON");
@@ -5209,6 +6909,303 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       eventHandlers: eventHandlers.length > 0 ? eventHandlers : void 0
     };
   }
+  // ===========================================================================
+  // SIMULATION CONTRACT BLOCK (v6.3)
+  // ===========================================================================
+  /**
+   * Parse a `sim_contract { ... }` block.
+   *
+   * Syntax:
+   * ```
+   * sim_contract {
+   *   precondition "name" { expr }
+   *   precondition "name" "description" { expr }
+   *   invariant "name" { expr }
+   *   receipt { field: type, ... }
+   * }
+   * ```
+   */
+  parseContractBlock() {
+    const startLoc = this.currentLocation();
+    this.pushContext("sim_contract");
+    this.advance();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const preconditions = [];
+    const invariants = [];
+    const receipt = {};
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const tokenLower = this.current().value.toLowerCase();
+      if ((tokenLower === "precondition" || tokenLower === "invariant") && this.check("IDENTIFIER")) {
+        const clauseKind = tokenLower;
+        this.advance();
+        let clauseName = "unnamed";
+        if (this.check("STRING")) {
+          clauseName = this.expectString();
+        } else if (this.check("IDENTIFIER")) {
+          clauseName = this.expectIdentifier();
+        }
+        let description;
+        if (this.check("STRING")) {
+          description = this.expectString();
+        }
+        let expr = "";
+        if (this.check("LBRACE")) {
+          this.advance();
+          const parts = [];
+          let depth = 1;
+          while (depth > 0 && !this.isAtEnd()) {
+            if (this.check("LBRACE")) depth++;
+            if (this.check("RBRACE")) {
+              depth--;
+              if (depth === 0) break;
+            }
+            parts.push(this.current().value);
+            this.advance();
+          }
+          this.expect("RBRACE");
+          expr = parts.join(" ").trim();
+        }
+        const clause = { name: clauseName, expr };
+        if (description !== void 0) clause.description = description;
+        if (clauseKind === "precondition") {
+          preconditions.push(clause);
+        } else {
+          invariants.push(clause);
+        }
+      } else if (tokenLower === "receipt" && this.check("IDENTIFIER")) {
+        this.advance();
+        if (this.check("LBRACE")) {
+          this.advance();
+          this.skipNewlines();
+          while (!this.check("RBRACE") && !this.isAtEnd()) {
+            this.skipNewlines();
+            if (this.check("RBRACE")) break;
+            let fieldName = "";
+            if (this.check("IDENTIFIER")) {
+              fieldName = this.expectIdentifier();
+            } else if (this.check("STRING")) {
+              fieldName = this.expectString();
+            } else {
+              this.advance();
+              continue;
+            }
+            let typeName = "unknown";
+            if (this.check("COLON")) {
+              this.advance();
+              if (this.check("IDENTIFIER")) {
+                typeName = this.expectIdentifier();
+              } else if (this.check("STRING")) {
+                typeName = this.expectString();
+              }
+            }
+            if (fieldName) receipt[fieldName] = typeName;
+            if (this.check("COMMA")) this.advance();
+            this.skipNewlines();
+          }
+          this.expect("RBRACE");
+        }
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "contract",
+      preconditions,
+      invariants,
+      receipt
+    };
+  }
+  // ── Pub/sub messaging primitives (v6.4) ───────────────────────────────────
+  /**
+   * Parse policy_pack Name { ... } as a first-class regulated-AI governance
+   * primitive. Validation lives in policy/PolicyPack.ts so compilers and deploy
+   * gates consume the same schema the parser emits.
+   */
+  parsePolicyPackBlock() {
+    const startLoc = this.currentLocation();
+    this.pushContext("policy-pack");
+    this.advance();
+    const name = this.check("STRING") ? this.expectString() : this.expectIdentifier();
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const properties = {};
+    let version = "1.0.0";
+    let frameworkId = "";
+    let requiredTests = [];
+    let requiredCompileTargets = [];
+    let auditRetention = {};
+    let monitoringCadence = {};
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const key = this.expectIdentifier();
+      if ((key === "audit_retention" || key === "auditRetention") && this.check("LBRACE")) {
+        auditRetention = this.parseBlockTraitConfig();
+      } else if ((key === "monitoring" || key === "monitoring_cadence" || key === "monitoringCadence") && this.check("LBRACE")) {
+        monitoringCadence = this.parseBlockTraitConfig();
+      } else {
+        this.expect("COLON");
+        const value = this.parseValue();
+        if (key === "version") version = typeof value === "string" ? value : String(value);
+        else if (key === "framework_id" || key === "frameworkId") {
+          frameworkId = typeof value === "string" ? value : String(value);
+        } else if (key === "required_tests" || key === "requiredTests") {
+          requiredTests = Array.isArray(value) ? value : [value];
+        } else if (key === "required_compile_targets" || key === "requiredCompileTargets") {
+          requiredCompileTargets = (Array.isArray(value) ? value : [value]).map(
+            (target) => String(target)
+          );
+        } else if (key === "audit_retention" || key === "auditRetention") {
+          auditRetention = this.asRecord(value);
+        } else if (key === "monitoring" || key === "monitoring_cadence" || key === "monitoringCadence") {
+          monitoringCadence = this.asRecord(value);
+        } else {
+          properties[key] = value;
+        }
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "PolicyPack",
+      name,
+      version,
+      frameworkId,
+      requiredTests,
+      requiredCompileTargets,
+      auditRetention,
+      monitoringCadence,
+      properties
+    };
+  }
+  asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || "__bind" in value) {
+      return {};
+    }
+    return value;
+  }
+  /** Parse `topic Name { type: "T" broadcast: true }` */
+  parseTopicBlock() {
+    const startLoc = this.currentLocation();
+    this.advance();
+    const name = this.check("IDENTIFIER") ? this.expectIdentifier() : "unnamed";
+    const metadata = {};
+    let dataType;
+    let broadcast;
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.isAtEnd()) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("NEWLINE")) {
+          if (!this.check("RBRACE")) this.advance();
+          continue;
+        }
+        const key = this.current().value;
+        this.advance();
+        if (this.check("COLON")) this.advance();
+        if (key === "type" || key === "dataType") {
+          dataType = this.check("STRING") ? this.expectString() : this.check("IDENTIFIER") ? this.expectIdentifier() : (this.advance(), void 0);
+        } else if (key === "broadcast") {
+          broadcast = this.current().value === "true";
+          this.advance();
+        } else if (this.check("LBRACE") || this.check("STRING") || this.check("NUMBER") || this.check("IDENTIFIER") || this.check("LBRACKET")) {
+          metadata[key] = this.parseValue();
+        }
+        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
+      }
+      this.expect("RBRACE");
+    }
+    const topic = {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "Topic",
+      name
+    };
+    if (dataType !== void 0) topic.dataType = dataType;
+    if (broadcast !== void 0) topic.broadcast = broadcast;
+    if (Object.keys(metadata).length > 0) topic.metadata = metadata;
+    return topic;
+  }
+  /** Parse `channel Name { from: A to: B capacity: N }` */
+  parseChannelBlock() {
+    const startLoc = this.currentLocation();
+    this.advance();
+    const name = this.check("IDENTIFIER") ? this.expectIdentifier() : "unnamed";
+    const metadata = {};
+    let from;
+    let to;
+    let capacity;
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.isAtEnd()) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("NEWLINE")) {
+          if (!this.check("RBRACE")) this.advance();
+          continue;
+        }
+        const key = this.current().value;
+        this.advance();
+        if (this.check("COLON")) this.advance();
+        if (key === "from") {
+          from = this.check("STRING") ? this.expectString() : this.check("IDENTIFIER") ? this.expectIdentifier() : void 0;
+        } else if (key === "to") {
+          to = this.check("STRING") ? this.expectString() : this.check("IDENTIFIER") ? this.expectIdentifier() : void 0;
+        } else if (key === "capacity") {
+          capacity = this.check("NUMBER") ? Number(this.current().value) : void 0;
+          if (capacity !== void 0) this.advance();
+        } else if (this.check("LBRACE") || this.check("STRING") || this.check("NUMBER") || this.check("IDENTIFIER") || this.check("LBRACKET")) {
+          metadata[key] = this.parseValue();
+        }
+        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
+      }
+      this.expect("RBRACE");
+    }
+    const ch = {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "Channel",
+      name
+    };
+    if (from !== void 0) ch.from = from;
+    if (to !== void 0) ch.to = to;
+    if (capacity !== void 0) ch.capacity = capacity;
+    if (Object.keys(metadata).length > 0) ch.metadata = metadata;
+    return ch;
+  }
+  /** Parse `connect Identifier to Identifier [as "edgeType"]` */
+  parseConnectionStmt() {
+    const startLoc = this.currentLocation();
+    this.advance();
+    const from = this.check("IDENTIFIER") ? this.expectIdentifier() : "";
+    if (this.check("IDENTIFIER") && this.current().value === "to") this.advance();
+    const to = this.check("IDENTIFIER") ? this.expectIdentifier() : "";
+    let edgeType;
+    if (this.check("IDENTIFIER") && this.current().value === "as") {
+      this.advance();
+      if (this.check("STRING")) edgeType = this.expectString();
+      else if (this.check("IDENTIFIER")) edgeType = this.expectIdentifier();
+    }
+    const conn = {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "Connection",
+      from,
+      to
+    };
+    if (edgeType !== void 0) conn.edgeType = edgeType;
+    return conn;
+  }
   /**
    * Unified parser for all domain-specific blocks.
    * Pattern: KEYWORD NAME @trait1 @trait2 { properties... }
@@ -5255,27 +7252,27 @@ var _HoloCompositionParser = class _HoloCompositionParser {
     if (domain === "pipeline" && keyword === "pipeline") {
       return this.parsePipelineDomainBlock(name, traits);
     }
+    if (token.type === "PCG_GRAPH") {
+      return this.parsePCGGraphDomainBlock(startLoc, name, traits, keyword, domain);
+    }
     this.expect("LBRACE");
     this.skipNewlines();
     const properties = {};
     const children = [];
     const eventHandlers = [];
     while (!this.check("RBRACE") && !this.isAtEnd()) {
-      this.skipNewlines();
+      this.skipBlockMemberSeparators();
       if (this.check("RBRACE")) break;
-      if (this.check("OBJECT") || this.check("IDENTIFIER") && PRIMITIVE_SHAPES.has(this.current().value)) {
+      if (this.check("OBJECT")) {
         children.push(this.parseObject());
+      } else if (this.check("IDENTIFIER") && this.isPrimitiveShape(this.current().value) && this.peek(1).type !== "COLON") {
+        children.push(this.parsePrimitiveObject());
       } else if (this.check("IDENTIFIER") && this.current().value.startsWith("on")) {
         const evtName = this.current().value;
         if (this.tokens[this.pos + 1]?.type === "LPAREN" || this.tokens[this.pos + 1]?.type === "LBRACE") {
           this.advance();
           if (this.check("LPAREN")) {
-            this.advance();
-            while (!this.check("RPAREN") && !this.isAtEnd()) {
-              this.expectIdentifier();
-              if (this.check("COMMA")) this.advance();
-            }
-            this.expect("RPAREN");
+            this.skipParens();
           }
           if (this.check("LBRACE")) {
             this.skipBlock();
@@ -5287,13 +7284,51 @@ var _HoloCompositionParser = class _HoloCompositionParser {
             body: []
           });
         } else {
-          const key = this.expectIdentifier();
+          const key = this.parsePropertyKey();
           this.expect("COLON");
           const value = this.parseValue();
           properties[key] = value;
         }
+      } else if (this.check("AT")) {
+        this.advance();
+        const traitName = this.parseTraitName();
+        if (traitName) traits.push(traitName);
+        if (this.check("LPAREN") || this.check("LBRACE") || this.check("COLON")) {
+          properties[`@${traitName}`] = this.parseOptionalTraitConfig();
+        }
+      } else if (this.isNamedOrTraitedPropertyBlockStart()) {
+        const { key, value } = this.parseNamedOrTraitedPropertyBlock();
+        properties[key] = value;
+      } else if (this.isPropertyName() && this.peek(1).type === "LBRACE") {
+        const key = this.parsePropertyKey();
+        properties[key] = this.parseBlockTraitConfig();
+      } else if (this.isPropertyName() && (this.peek(1).type === "STRING" || this.peek(1).type === "IDENTIFIER") && this.peek(2).type === "LBRACE") {
+        const key = this.parsePropertyKey();
+        const blockName = this.advance().value;
+        properties[key] = {
+          name: blockName,
+          ...this.parseBlockTraitConfig()
+        };
+      } else if (this.isPropertyName() && (this.peek(1).type === "ARROW" || this.peek(1).type === "MINUS" && this.peek(2).type === "GREATER")) {
+        const from = this.parsePropertyKey();
+        if (this.check("ARROW")) {
+          this.advance();
+        } else {
+          this.advance();
+          this.advance();
+        }
+        if (domain === "input") {
+          properties[from] = this.parseValue();
+          if (this.check("COMMA")) this.advance();
+          this.skipNewlines();
+          continue;
+        }
+        const to = this.isBarewordPathToken() ? this.parseBarewordPathValue() : "";
+        const existing = properties.connections;
+        const connection = { from, to };
+        properties.connections = Array.isArray(existing) ? [...existing, connection] : [connection];
       } else {
-        const key = this.expectIdentifier();
+        const key = this.parsePropertyKey();
         this.expect("COLON");
         const value = this.parseValue();
         properties[key] = value;
@@ -5315,6 +7350,90 @@ var _HoloCompositionParser = class _HoloCompositionParser {
       eventHandlers: eventHandlers.length > 0 ? eventHandlers : void 0
     };
   }
+  parsePCGGraphDomainBlock(startLoc, name, traits, keyword, domain) {
+    this.expect("LBRACE");
+    this.skipNewlines();
+    const nodes = [];
+    const properties = {
+      nodes
+    };
+    while (!this.check("RBRACE") && !this.isAtEnd()) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const token = this.current();
+      const next = this.peek(1);
+      if (next?.type === "COLON" && (token.type === "IDENTIFIER" || token.type === "PCG_GRAPH")) {
+        const key = token.value;
+        this.advance();
+        this.expect("COLON");
+        properties[key] = this.parseValue();
+      } else {
+        const kind = token.value;
+        this.advance();
+        const nodeProperties = {};
+        if (this.check("LPAREN")) {
+          this.parsePCGNodeArgs(kind, nodeProperties);
+        }
+        nodes.push({
+          kind,
+          properties: nodeProperties
+        });
+      }
+      this.skipNewlines();
+      if (this.check("ARROW")) {
+        this.advance();
+      } else if (this.check("MINUS") && this.peek(1).type === "GREATER") {
+        this.advance();
+        this.advance();
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE");
+    this.popContext();
+    return {
+      loc: { start: startLoc, end: this.currentLocation() },
+      type: "DomainBlock",
+      domain,
+      keyword,
+      name,
+      traits,
+      properties
+    };
+  }
+  parsePCGNodeArgs(kind, properties) {
+    this.expect("LPAREN");
+    const args = [];
+    while (!this.check("RPAREN") && !this.isAtEnd()) {
+      if (this.check("COMMA")) {
+        this.advance();
+        continue;
+      }
+      if (this.check("IDENTIFIER") && this.peek(1).type === "COLON") {
+        const key = this.expectIdentifier();
+        this.expect("COLON");
+        properties[key] = this.parseValue();
+      } else {
+        args.push(this.parsePCGArgumentValue());
+      }
+      if (this.check("COMMA")) this.advance();
+    }
+    this.expect("RPAREN");
+    if (kind === "scatter") {
+      if (args[0] !== void 0) properties["source_mesh"] = args[0];
+      if (args[1] !== void 0) properties["count"] = args[1];
+    } else if (args.length > 0) {
+      properties["args"] = args;
+    }
+  }
+  parsePCGArgumentValue() {
+    if (this.check("STRING") || this.check("NUMBER") || this.check("BOOLEAN") || this.check("NULL") || this.check("LBRACKET")) {
+      return this.parseValue();
+    }
+    const value = this.current().value;
+    this.advance();
+    return value;
+  }
   /**
    * Parse a pipeline domain block by extracting the raw body text
    * and delegating to PipelineParser for structured AST.
@@ -5453,6 +7572,10 @@ _HoloCompositionParser.DOMAIN_TOKENS = /* @__PURE__ */ new Set([
   "SIMULATION",
   // Perception & simulation layer
   "MATERIAL",
+  "MATERIAL_GRAPH",
+  "LIGHT_FIELD",
+  "NAV_FIELD",
+  "PHYSICS_CONTRACT",
   "PBR_MATERIAL",
   "UNLIT_MATERIAL",
   "SHADER",
@@ -5463,6 +7586,7 @@ _HoloCompositionParser.DOMAIN_TOKENS = /* @__PURE__ */ new Set([
   "PARTICLES",
   "EMITTER",
   "VFX",
+  "PARTICLE_FIELD",
   "POST_PROCESSING",
   "POST_FX",
   "AUDIO_SOURCE",
@@ -5471,6 +7595,7 @@ _HoloCompositionParser.DOMAIN_TOKENS = /* @__PURE__ */ new Set([
   "WEATHER",
   "ATMOSPHERE",
   "PROCEDURAL",
+  "PCG_GRAPH",
   "SCATTER",
   "LOD_BLOCK",
   "RENDER",
@@ -5540,7 +7665,9 @@ _HoloCompositionParser.DOMAIN_TOKENS = /* @__PURE__ */ new Set([
   "RETRY_BLOCK",
   "TIMEOUT_BLOCK",
   "FALLBACK_BLOCK",
-  "BULKHEAD_BLOCK"
+  "BULKHEAD_BLOCK",
+  // MMO/AAA game constructs (v6.2) — real_estate only; others handled by dedicated parsers
+  "REAL_ESTATE"
 ]);
 /** Token → domain type mapping */
 _HoloCompositionParser.TOKEN_DOMAIN_MAP = {
@@ -5582,6 +7709,10 @@ _HoloCompositionParser.TOKEN_DOMAIN_MAP = {
   SIMULATION: "simulation",
   // Perception & simulation layer
   MATERIAL: "material",
+  MATERIAL_GRAPH: "material_graph",
+  LIGHT_FIELD: "light_field",
+  NAV_FIELD: "nav_field",
+  PHYSICS_CONTRACT: "physics_contract",
   PBR_MATERIAL: "material",
   UNLIT_MATERIAL: "material",
   SHADER: "material",
@@ -5592,6 +7723,7 @@ _HoloCompositionParser.TOKEN_DOMAIN_MAP = {
   PARTICLES: "vfx",
   EMITTER: "vfx",
   VFX: "vfx",
+  PARTICLE_FIELD: "particle_field",
   POST_PROCESSING: "postfx",
   POST_FX: "postfx",
   AUDIO_SOURCE: "audio",
@@ -5600,6 +7732,7 @@ _HoloCompositionParser.TOKEN_DOMAIN_MAP = {
   WEATHER: "weather",
   ATMOSPHERE: "weather",
   PROCEDURAL: "procedural",
+  PCG_GRAPH: "procedural",
   SCATTER: "procedural",
   LOD_BLOCK: "rendering",
   RENDER: "rendering",
@@ -5669,7 +7802,9 @@ _HoloCompositionParser.TOKEN_DOMAIN_MAP = {
   RETRY_BLOCK: "resilience",
   TIMEOUT_BLOCK: "resilience",
   FALLBACK_BLOCK: "resilience",
-  BULKHEAD_BLOCK: "resilience"
+  BULKHEAD_BLOCK: "resilience",
+  // MMO/AAA game constructs (v6.2)
+  REAL_ESTATE: "custom"
 };
 var HoloCompositionParser = _HoloCompositionParser;
 function parseHolo(source, options) {
@@ -5739,6 +7874,6 @@ function parseHoloPartial(source, options) {
   };
 }
 
-export { HoloCompositionParser, parseHolo, parseHoloPartial, parseHoloStrict };
-//# sourceMappingURL=chunk-OABEO6HH.js.map
-//# sourceMappingURL=chunk-OABEO6HH.js.map
+export { HoloCompositionParser, KEYWORDS, LIGHT_PRIMITIVES, PRIMITIVE_SHAPES, parseHolo, parseHoloPartial, parseHoloStrict };
+//# sourceMappingURL=chunk-SZOLTWWD.js.map
+//# sourceMappingURL=chunk-SZOLTWWD.js.map