@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-YIMN575O.js

@@ -0,0 +1,4847 @@
+import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-4N4SXXWF.js';
+import { VR_TRAITS } from './chunk-2BSMSUCE.js';
+import * as crypto from 'crypto';
+
+// src/parser/HybridChunker.ts
+function countTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function detectFileType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() || "";
+  if (["ts", "js", "jsx", "tsx", "hs", "hsplus"].includes(ext)) {
+    return "code";
+  }
+  if (["log", "txt", "csv"].includes(ext)) {
+    return "log";
+  }
+  if (["md", "mdx", "markdown"].includes(ext)) {
+    return "markdown";
+  }
+  return "unknown";
+}
+var StructureBasedChunker = class {
+  constructor(options) {
+    this.options = {
+      maxTokens: options.maxTokens || 1024,
+      overlapTokens: options.overlapTokens || 100,
+      semanticThreshold: options.semanticThreshold || 0.85,
+      debug: options.debug || false
+    };
+  }
+  /**
+   * Chunk code files by detecting structural boundaries
+   */
+  chunk(content, filePath) {
+    const lines = content.split("\n");
+    const boundaries = this.detectStructuralBoundaries(lines);
+    if (boundaries.length === 0) {
+      return [
+        {
+          id: `structure:${filePath}:0`,
+          type: "code-block",
+          startLine: 1,
+          endLine: lines.length,
+          content,
+          tokens: countTokens(content),
+          strategy: "structure"
+        }
+      ];
+    }
+    const chunks = [];
+    let currentChunk = [];
+    let currentStart = 1;
+    let chunkIndex = 0;
+    for (let i = 0; i < boundaries.length; i++) {
+      const boundary = boundaries[i];
+      const segmentContent = lines.slice(boundary.startLine - 1, boundary.endLine).join("\n");
+      const segmentTokens = countTokens(segmentContent);
+      if (currentChunk.length > 0 && countTokens(currentChunk.join("\n") + "\n" + segmentContent) > this.options.maxTokens) {
+        const chunkContent = currentChunk.join("\n");
+        chunks.push({
+          id: `structure:${filePath}:${chunkIndex++}`,
+          type: "code-block",
+          startLine: currentStart,
+          endLine: currentStart + currentChunk.length - 1,
+          content: chunkContent,
+          tokens: countTokens(chunkContent),
+          strategy: "structure"
+        });
+        currentChunk = [];
+        currentStart = boundary.startLine;
+      }
+      if (segmentTokens > this.options.maxTokens) {
+        const subChunks = this.recursiveSplit(
+          segmentContent,
+          boundary.startLine,
+          filePath,
+          chunkIndex
+        );
+        chunks.push(...subChunks);
+        chunkIndex += subChunks.length;
+      } else {
+        currentChunk.push(segmentContent);
+      }
+    }
+    if (currentChunk.length > 0) {
+      const chunkContent = currentChunk.join("\n");
+      chunks.push({
+        id: `structure:${filePath}:${chunkIndex}`,
+        type: "code-block",
+        startLine: currentStart,
+        endLine: currentStart + currentChunk.length - 1,
+        content: chunkContent,
+        tokens: countTokens(chunkContent),
+        strategy: "structure"
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Detect structural boundaries (functions, classes, interfaces)
+   */
+  detectStructuralBoundaries(lines) {
+    const boundaries = [];
+    let braceDepth = 0;
+    let currentBlock = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!currentBlock) {
+        const functionMatch = trimmed.match(
+          /^(export\s+)?(async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/
+        );
+        const classMatch = trimmed.match(
+          /^(export\s+)?(abstract\s+)?class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/
+        );
+        const interfaceMatch = trimmed.match(/^(export\s+)?interface\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+        const methodMatch = trimmed.match(
+          /^(public|private|protected|static)?\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\([^)]*\)\s*[:{]/
+        );
+        if (functionMatch) {
+          currentBlock = {
+            type: "function",
+            name: functionMatch[3],
+            startLine: i + 1
+          };
+        } else if (classMatch) {
+          currentBlock = {
+            type: "class",
+            name: classMatch[3],
+            startLine: i + 1
+          };
+        } else if (interfaceMatch) {
+          currentBlock = {
+            type: "interface",
+            name: interfaceMatch[2],
+            startLine: i + 1
+          };
+        } else if (methodMatch) {
+          currentBlock = {
+            type: "method",
+            name: methodMatch[2],
+            startLine: i + 1
+          };
+        }
+      }
+      if (currentBlock) {
+        for (const char of line) {
+          if (char === "{") braceDepth++;
+          if (char === "}") braceDepth--;
+        }
+        if (braceDepth === 0 && trimmed.includes("}")) {
+          boundaries.push({
+            type: currentBlock.type,
+            name: currentBlock.name,
+            startLine: currentBlock.startLine,
+            endLine: i + 1
+          });
+          currentBlock = null;
+        }
+      }
+    }
+    if (currentBlock) {
+      boundaries.push({
+        type: currentBlock.type,
+        name: currentBlock.name,
+        startLine: currentBlock.startLine,
+        endLine: lines.length
+      });
+    }
+    return boundaries;
+  }
+  /**
+   * Recursively split large segments
+   */
+  recursiveSplit(content, startLine, filePath, baseIndex) {
+    const lines = content.split("\n");
+    const chunks = [];
+    let currentChunk = [];
+    let currentStart = startLine;
+    for (let i = 0; i < lines.length; i++) {
+      currentChunk.push(lines[i]);
+      if (countTokens(currentChunk.join("\n")) >= this.options.maxTokens) {
+        const chunkContent = currentChunk.join("\n");
+        chunks.push({
+          id: `structure:${filePath}:${baseIndex + chunks.length}`,
+          type: "code-fragment",
+          startLine: currentStart,
+          endLine: currentStart + currentChunk.length - 1,
+          content: chunkContent,
+          tokens: countTokens(chunkContent),
+          strategy: "structure",
+          metadata: { splitReason: "recursive-oversized" }
+        });
+        currentChunk = [];
+        currentStart = startLine + i + 1;
+      }
+    }
+    if (currentChunk.length > 0) {
+      const chunkContent = currentChunk.join("\n");
+      chunks.push({
+        id: `structure:${filePath}:${baseIndex + chunks.length}`,
+        type: "code-fragment",
+        startLine: currentStart,
+        endLine: currentStart + currentChunk.length - 1,
+        content: chunkContent,
+        tokens: countTokens(chunkContent),
+        strategy: "structure"
+      });
+    }
+    return chunks;
+  }
+};
+var FixedSizeChunker = class {
+  constructor(options) {
+    this.options = {
+      maxTokens: options.maxTokens || 1024,
+      overlapTokens: options.overlapTokens || 100,
+      semanticThreshold: options.semanticThreshold || 0.85,
+      debug: options.debug || false
+    };
+  }
+  /**
+   * Chunk text files into fixed-size segments with overlap
+   */
+  chunk(content, filePath) {
+    const lines = content.split("\n");
+    const chunks = [];
+    let currentChunk = [];
+    let currentStart = 1;
+    let chunkIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      currentChunk.push(lines[i]);
+      const currentTokens = countTokens(currentChunk.join("\n"));
+      if (currentTokens >= this.options.maxTokens) {
+        const chunkContent = currentChunk.join("\n");
+        chunks.push({
+          id: `fixed:${filePath}:${chunkIndex++}`,
+          type: "text-block",
+          startLine: currentStart,
+          endLine: currentStart + currentChunk.length - 1,
+          content: chunkContent,
+          tokens: currentTokens,
+          strategy: "fixed"
+        });
+        const overlapLines = this.calculateOverlapLines(currentChunk);
+        currentChunk = overlapLines;
+        currentStart = currentStart + currentChunk.length - overlapLines.length;
+      }
+    }
+    if (currentChunk.length > 0) {
+      const chunkContent = currentChunk.join("\n");
+      chunks.push({
+        id: `fixed:${filePath}:${chunkIndex}`,
+        type: "text-block",
+        startLine: currentStart,
+        endLine: currentStart + currentChunk.length - 1,
+        content: chunkContent,
+        tokens: countTokens(chunkContent),
+        strategy: "fixed"
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Calculate overlap lines based on token count
+   */
+  calculateOverlapLines(lines) {
+    const overlapLines = [];
+    let overlapTokens = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const lineTokens = countTokens(lines[i]);
+      if (overlapTokens + lineTokens > this.options.overlapTokens) {
+        break;
+      }
+      overlapLines.unshift(lines[i]);
+      overlapTokens += lineTokens;
+    }
+    return overlapLines;
+  }
+};
+var SemanticChunker = class {
+  constructor(options) {
+    this.options = {
+      maxTokens: options.maxTokens || 1024,
+      overlapTokens: options.overlapTokens || 100,
+      semanticThreshold: options.semanticThreshold || 0.85,
+      debug: options.debug || false
+    };
+  }
+  /**
+   * Chunk markdown/docs by semantic similarity
+   */
+  chunk(content, filePath) {
+    const paragraphs = this.detectParagraphs(content);
+    if (paragraphs.length === 0) {
+      return [
+        {
+          id: `semantic:${filePath}:0`,
+          type: "document",
+          startLine: 1,
+          endLine: content.split("\n").length,
+          content,
+          tokens: countTokens(content),
+          strategy: "semantic"
+        }
+      ];
+    }
+    const chunks = [];
+    let currentGroup = [];
+    let chunkIndex = 0;
+    for (let i = 0; i < paragraphs.length; i++) {
+      const para = paragraphs[i];
+      if (currentGroup.length === 0) {
+        currentGroup.push(para);
+        continue;
+      }
+      const lastPara = currentGroup[currentGroup.length - 1];
+      const similarity2 = this.computeSimilarity(lastPara.content, para.content);
+      const groupContent = currentGroup.map((p) => p.content).join("\n\n");
+      const groupTokens = countTokens(groupContent + "\n\n" + para.content);
+      if (similarity2 >= this.options.semanticThreshold && groupTokens <= this.options.maxTokens) {
+        currentGroup.push(para);
+      } else {
+        const chunkContent = currentGroup.map((p) => p.content).join("\n\n");
+        chunks.push({
+          id: `semantic:${filePath}:${chunkIndex++}`,
+          type: "semantic-group",
+          startLine: currentGroup[0].startLine,
+          endLine: currentGroup[currentGroup.length - 1].endLine,
+          content: chunkContent,
+          tokens: countTokens(chunkContent),
+          strategy: "semantic",
+          metadata: {
+            paragraphCount: currentGroup.length
+          }
+        });
+        currentGroup = [para];
+      }
+    }
+    if (currentGroup.length > 0) {
+      const chunkContent = currentGroup.map((p) => p.content).join("\n\n");
+      chunks.push({
+        id: `semantic:${filePath}:${chunkIndex}`,
+        type: "semantic-group",
+        startLine: currentGroup[0].startLine,
+        endLine: currentGroup[currentGroup.length - 1].endLine,
+        content: chunkContent,
+        tokens: countTokens(chunkContent),
+        strategy: "semantic",
+        metadata: {
+          paragraphCount: currentGroup.length
+        }
+      });
+    }
+    return chunks;
+  }
+  /**
+   * Detect paragraph boundaries in markdown
+   */
+  detectParagraphs(content) {
+    const lines = content.split("\n");
+    const paragraphs = [];
+    let currentPara = [];
+    let currentStart = 1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#") || /^[-*+]\s/.test(trimmed) || /^\d+\.\s/.test(trimmed)) {
+        if (currentPara.length > 0) {
+          paragraphs.push({
+            content: currentPara.join("\n"),
+            startLine: currentStart,
+            endLine: i
+          });
+          currentPara = [];
+        }
+        if (trimmed !== "") {
+          currentPara.push(line);
+          currentStart = i + 1;
+        } else {
+          currentStart = i + 2;
+        }
+      } else {
+        currentPara.push(line);
+      }
+    }
+    if (currentPara.length > 0) {
+      paragraphs.push({
+        content: currentPara.join("\n"),
+        startLine: currentStart,
+        endLine: lines.length
+      });
+    }
+    return paragraphs;
+  }
+  /**
+   * Compute similarity between two text segments
+   *
+   * Simple heuristic: Jaccard similarity of word sets
+   * For production: Use sentence-transformers embeddings + cosine similarity
+   */
+  computeSimilarity(text1, text2) {
+    const words1 = new Set(
+      text1.toLowerCase().split(/\s+/).filter((w) => w.length > 3)
+    );
+    const words2 = new Set(
+      text2.toLowerCase().split(/\s+/).filter((w) => w.length > 3)
+    );
+    const intersection = new Set([...words1].filter((w) => words2.has(w)));
+    const union = /* @__PURE__ */ new Set([...words1, ...words2]);
+    return union.size > 0 ? intersection.size / union.size : 0;
+  }
+};
+var HybridChunker = class {
+  constructor(options = {}) {
+    this.options = {
+      maxTokens: options.maxTokens || 1024,
+      overlapTokens: options.overlapTokens || 100,
+      semanticThreshold: options.semanticThreshold || 0.85,
+      debug: options.debug || false
+    };
+    this.structureChunker = new StructureBasedChunker(this.options);
+    this.fixedChunker = new FixedSizeChunker(this.options);
+    this.semanticChunker = new SemanticChunker(this.options);
+  }
+  /**
+   * Chunk a file using the optimal strategy
+   */
+  chunk(content, filePath) {
+    const fileType = detectFileType(filePath);
+    this.log(`Chunking ${filePath} (type: ${fileType})`);
+    let chunks;
+    switch (fileType) {
+      case "code":
+        chunks = this.structureChunker.chunk(content, filePath);
+        break;
+      case "log":
+        chunks = this.fixedChunker.chunk(content, filePath);
+        break;
+      case "markdown":
+        chunks = this.semanticChunker.chunk(content, filePath);
+        break;
+      default:
+        this.log(`Unknown file type for ${filePath}, using fixed-size chunking`);
+        chunks = this.fixedChunker.chunk(content, filePath);
+    }
+    this.log(
+      `Generated ${chunks.length} chunks (${chunks.reduce((sum, c) => sum + c.tokens, 0)} total tokens)`
+    );
+    return chunks;
+  }
+  /**
+   * Get chunking statistics
+   */
+  getStats(chunks) {
+    const totalTokens = chunks.reduce((sum, c) => sum + c.tokens, 0);
+    const strategyDistribution = {};
+    for (const chunk of chunks) {
+      strategyDistribution[chunk.strategy] = (strategyDistribution[chunk.strategy] || 0) + 1;
+    }
+    return {
+      totalChunks: chunks.length,
+      totalTokens,
+      avgTokensPerChunk: chunks.length > 0 ? totalTokens / chunks.length : 0,
+      strategyDistribution
+    };
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[HybridChunker] ${message}`);
+    }
+  }
+};
+function createHybridChunker(options) {
+  return new HybridChunker(options);
+}
+
+// src/parser/ChunkDetector.ts
+var ChunkDetector = class {
+  /**
+   * Detects chunks in the source code based on top-level keywords
+   *
+   * @deprecated Use detectHybrid() for better performance with multi-strategy chunking
+   */
+  static detect(source) {
+    const lines = source.split(/\r?\n/);
+    const chunks = [];
+    let currentChunk = null;
+    let braceDepth = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+      if (!currentChunk && (!trimmed || trimmed.startsWith("//"))) {
+        continue;
+      }
+      if (!currentChunk) {
+        const orbMatch = trimmed.match(/^orb\s+([a-zA-Z0-9_#"]+)/);
+        const templateMatch = trimmed.match(/^template\s+"([^"]+)"/);
+        const envMatch = trimmed.startsWith("environment");
+        const logicMatch = trimmed.startsWith("logic");
+        const directiveMatch = trimmed.startsWith("@");
+        if (orbMatch || templateMatch || envMatch || logicMatch || directiveMatch) {
+          currentChunk = {
+            startLine: i + 1,
+            content: line
+          };
+          if (orbMatch) {
+            currentChunk.type = "orb";
+            currentChunk.name = orbMatch[1].replace(/[#"]/g, "");
+            currentChunk.id = `orb:${currentChunk.name}`;
+          } else if (templateMatch) {
+            currentChunk.type = "template";
+            currentChunk.name = templateMatch[1];
+            currentChunk.id = `template:${currentChunk.name}`;
+          } else if (envMatch) {
+            currentChunk.type = "environment";
+            currentChunk.id = `environment:${i + 1}`;
+          } else if (logicMatch) {
+            currentChunk.type = "logic";
+            currentChunk.id = `logic:${i + 1}`;
+          } else if (directiveMatch) {
+            currentChunk.type = "directive";
+            if (!trimmed.includes("{")) {
+              currentChunk.endLine = i + 1;
+              currentChunk.id = `directive:${i + 1}`;
+              chunks.push(currentChunk);
+              currentChunk = null;
+              continue;
+            }
+            currentChunk.id = `directive:${i + 1}`;
+          }
+        }
+      } else {
+        currentChunk.content += "\n" + line;
+      }
+      if (currentChunk) {
+        for (const char of line) {
+          if (char === "{") braceDepth++;
+          if (char === "}") braceDepth--;
+        }
+        if (braceDepth === 0) {
+          currentChunk.endLine = i + 1;
+          chunks.push(currentChunk);
+          currentChunk = null;
+        }
+      }
+    }
+    if (currentChunk) {
+      currentChunk.endLine = lines.length;
+      chunks.push(currentChunk);
+    }
+    return chunks;
+  }
+  /**
+   * Detect chunks using HybridChunker (structure-based + semantic + fixed-size)
+   *
+   * Routes .hs/.hsplus files to structure-based chunking for better performance.
+   * This method provides 20-30% better parsing speed by using AST-aware boundaries.
+   *
+   * @param source - Source code content
+   * @param filePath - File path for type detection (defaults to .hsplus)
+   * @param options - Chunking options
+   */
+  static detectHybrid(source, filePath = "file.hsplus", options) {
+    const hybridChunker = createHybridChunker(options);
+    const chunks = hybridChunker.chunk(source, filePath);
+    return chunks.map((chunk) => ({
+      id: chunk.id,
+      type: this.mapChunkType(chunk.type),
+      name: chunk.name,
+      startLine: chunk.startLine,
+      endLine: chunk.endLine,
+      content: chunk.content,
+      tokens: chunk.tokens,
+      strategy: chunk.strategy,
+      metadata: chunk.metadata
+    }));
+  }
+  /**
+   * Map HybridChunker types to ChunkDetector types
+   */
+  static mapChunkType(hybridType) {
+    if (hybridType.includes("class")) return "template";
+    if (hybridType.includes("function")) return "logic";
+    return "unknown";
+  }
+};
+var ParseCache = class {
+  constructor(maxEntries = 500) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.evictionCount = 0;
+    /** Monotonically increasing counter for reliable LRU ordering */
+    this.clock = 0;
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * Generates a hash for the chunk content
+   */
+  static hash(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+  }
+  /**
+   * Retrieves a cached node if the hash matches
+   */
+  get(id, currentHash) {
+    const cached = this.cache.get(id);
+    if (cached && cached.hash === currentHash) {
+      cached.lastUsed = ++this.clock;
+      return cached.node;
+    }
+    return null;
+  }
+  /**
+   * Stores a node in the cache
+   */
+  set(id, hash, node) {
+    if (this.cache.size >= this.maxEntries) {
+      this.evictOldest();
+    }
+    this.cache.set(id, {
+      id,
+      hash,
+      node,
+      lastUsed: ++this.clock
+    });
+  }
+  /**
+   * Clears the entire cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Returns cache statistics: current size, total evictions, and capacity.
+   */
+  getStats() {
+    return {
+      size: this.cache.size,
+      evictions: this.evictionCount,
+      maxEntries: this.maxEntries
+    };
+  }
+  evictOldest() {
+    let oldestId = null;
+    let oldestTime = Infinity;
+    for (const [id, entry] of this.cache.entries()) {
+      if (entry.lastUsed < oldestTime) {
+        oldestTime = entry.lastUsed;
+        oldestId = id;
+      }
+    }
+    if (oldestId) {
+      this.cache.delete(oldestId);
+      this.evictionCount++;
+    }
+  }
+};
+var globalParseCache = new ParseCache();
+
+// src/parser/IncrementalParser.ts
+var ChunkBasedIncrementalParser = class {
+  constructor(cache = globalParseCache) {
+    this.lastSource = "";
+    this.lastChunks = /* @__PURE__ */ new Map();
+    this.cache = cache;
+    this.parser = new HoloScriptPlusParser({
+      enableVRTraits: true,
+      enableTypeScriptImports: true,
+      strict: false
+    });
+  }
+  /**
+   * Parse source with incremental caching
+   */
+  parse(source) {
+    const startTime = Date.now();
+    let cached = 0;
+    let parsed = 0;
+    const changedChunks = [];
+    const currentChunks = this.detectChunks(source);
+    const chunkMap = new Map(currentChunks.map((c) => [c.id, c]));
+    const changedIds = this.identifyChangedChunks(currentChunks);
+    changedChunks.push(...changedIds);
+    const dependentIds = this.findDependents(changedIds, currentChunks);
+    const toParseIds = /* @__PURE__ */ new Set([...changedIds, ...dependentIds]);
+    const chunkNodes = /* @__PURE__ */ new Map();
+    for (const chunk of currentChunks) {
+      const hash = ParseCache.hash(chunk.content);
+      if (toParseIds.has(chunk.id)) {
+        const chunkNode = this.parseChunk(chunk);
+        if (chunkNode) {
+          chunkNodes.set(chunk.id, chunkNode);
+          this.cache.set(chunk.id, hash, chunkNode);
+          parsed++;
+        }
+      } else {
+        const cached_node = this.cache.get(chunk.id, hash);
+        if (cached_node) {
+          chunkNodes.set(chunk.id, cached_node);
+          cached++;
+        } else {
+          const chunkNode = this.parseChunk(chunk);
+          if (chunkNode) {
+            chunkNodes.set(chunk.id, chunkNode);
+            this.cache.set(chunk.id, hash, chunkNode);
+            parsed++;
+          }
+        }
+      }
+    }
+    const ast = this.assembleAST(chunkNodes, currentChunks);
+    this.lastSource = source;
+    this.lastChunks = chunkMap;
+    const duration = Date.now() - startTime;
+    return {
+      ast,
+      cached,
+      parsed,
+      duration,
+      changedChunks
+    };
+  }
+  /**
+   * Detects top-level chunks in the source
+   */
+  detectChunks(source) {
+    return ChunkDetector.detect(source);
+  }
+  /**
+   * Identifies which chunks have changed by comparing hashes
+   */
+  identifyChangedChunks(currentChunks) {
+    const changed = [];
+    for (const chunk of currentChunks) {
+      const hash = ParseCache.hash(chunk.content);
+      const lastChunk = this.lastChunks.get(chunk.id);
+      if (!lastChunk) {
+        changed.push(chunk.id);
+      } else {
+        const lastHash = ParseCache.hash(lastChunk.content);
+        if (hash !== lastHash) {
+          changed.push(chunk.id);
+        }
+      }
+    }
+    for (const [id, _lastChunk] of this.lastChunks.entries()) {
+      const currentChunk = this.detectChunks(this.lastSource).find((c) => c.id === id);
+      if (!currentChunk) {
+        changed.push(id);
+      }
+    }
+    return changed;
+  }
+  /**
+   * Finds chunks that depend on the changed ones
+   */
+  findDependents(changedIds, chunks) {
+    const dependents = /* @__PURE__ */ new Set();
+    const changeSet = new Set(changedIds);
+    const references = /* @__PURE__ */ new Map();
+    for (const chunk of chunks) {
+      const refs = this.extractReferences(chunk.content);
+      if (refs.size > 0) {
+        references.set(chunk.id, refs);
+      }
+    }
+    for (const [chunkId, refs] of references.entries()) {
+      if (!changeSet.has(chunkId)) {
+        for (const ref of refs) {
+          if (changeSet.has(ref) || dependents.has(ref)) {
+            dependents.add(chunkId);
+            break;
+          }
+        }
+      }
+    }
+    return Array.from(dependents);
+  }
+  /**
+   * Extracts referenced identifiers from a chunk (templates, orbs, logic)
+   */
+  extractReferences(content) {
+    const refs = /* @__PURE__ */ new Set();
+    const templateRefs = content.match(/using\s+"([^"]+)"/g);
+    if (templateRefs) {
+      templateRefs.forEach((ref) => {
+        const name = ref.match(/"([^"]+)"/)[1];
+        refs.add(`template:${name}`);
+      });
+    }
+    const spreadRefs = content.match(/\.\.\.\s*([a-zA-Z0-9_]+)/g);
+    if (spreadRefs) {
+      spreadRefs.forEach((ref) => {
+        const name = ref.replace(/\.\.\./, "").trim();
+        refs.add(`identifier:${name}`);
+      });
+    }
+    const compRefs = content.match(/@composition\s+"([^"]+)"/g);
+    if (compRefs) {
+      compRefs.forEach((ref) => {
+        const name = ref.match(/"([^"]+)"/)[1];
+        refs.add(`composition:${name}`);
+      });
+    }
+    return refs;
+  }
+  /**
+   * Parses a single chunk
+   */
+  parseChunk(chunk) {
+    try {
+      const content = this.wrapChunkForParsing(chunk);
+      const result = this.parser.parse(content);
+      if (result.success && result.ast) {
+        return result.ast;
+      }
+      return null;
+    } catch (error) {
+      console.warn(`Failed to parse chunk ${chunk.id}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Wraps chunk content to make it parseable in isolation
+   */
+  wrapChunkForParsing(chunk) {
+    return chunk.content;
+  }
+  /**
+   * Assembles final AST from parsed chunks
+   */
+  assembleAST(chunkNodes, chunks) {
+    const children = [];
+    for (const chunk of chunks) {
+      const node = chunkNodes.get(chunk.id);
+      if (node) {
+        children.push(node);
+      }
+    }
+    if (children.length === 1) {
+      return children[0];
+    }
+    return {
+      type: "fragment",
+      children,
+      properties: {},
+      directives: [],
+      traits: /* @__PURE__ */ new Map(),
+      loc: { start: { line: 1, column: 0 }, end: { line: 1, column: 0 } }
+    };
+  }
+  /**
+   * Clears the internal cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.lastChunks.clear();
+  }
+  /**
+   * Gets cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.lastChunks.size,
+      maxSize: 500
+    };
+  }
+};
+function parseIncrementalChunks(source, cache = globalParseCache) {
+  const parser = new ChunkBasedIncrementalParser(cache);
+  return parser.parse(source);
+}
+
+// src/parser/RichErrors.ts
+var HSPLUS_ERROR_CODES = {
+  // Syntax Errors (HSP001-HSP099)
+  HSP001: "Unexpected token",
+  HSP002: "Expected identifier",
+  HSP003: "Expected keyword",
+  HSP004: "Unclosed brace - missing }",
+  HSP005: "Unclosed bracket - missing ]",
+  HSP006: "Unclosed parenthesis - missing )",
+  HSP007: "Unclosed string literal",
+  HSP008: "Invalid number format",
+  HSP009: "Missing colon after property name",
+  HSP010: "Missing value after colon",
+  // Structure Errors (HSP100-HSP199)
+  HSP100: "Invalid composition structure",
+  HSP101: "Invalid object definition",
+  HSP102: "Invalid template definition",
+  HSP103: "Invalid spatial_group definition",
+  HSP104: "Invalid environment block",
+  HSP105: "Invalid state block",
+  HSP106: "Invalid logic block",
+  HSP107: "Duplicate identifier",
+  HSP108: "Missing required property",
+  // Trait Errors (HSP200-HSP299)
+  HSP200: "Unknown trait",
+  HSP201: "Invalid trait syntax",
+  HSP202: "Missing trait argument",
+  HSP203: "Invalid trait argument type",
+  HSP204: "Trait not allowed in this context",
+  HSP205: "Duplicate trait",
+  // Expression Errors (HSP300-HSP399)
+  HSP300: "Invalid expression",
+  HSP301: "Undefined variable",
+  HSP302: "Invalid operator",
+  HSP303: "Type mismatch",
+  HSP304: "Invalid function call",
+  HSP305: "Missing function argument",
+  // Import/Module Errors (HSP400-HSP499)
+  HSP400: "Invalid import statement",
+  HSP401: "Module not found",
+  HSP402: "Circular import detected",
+  // Limit Errors (HSP900-HSP999)
+  HSP900: "Maximum nesting depth exceeded",
+  HSP901: "Maximum array length exceeded",
+  HSP902: "Maximum string length exceeded"
+};
+function levenshteinDistance(a, b) {
+  const matrix = [];
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          // substitution
+          matrix[i][j - 1] + 1,
+          // insertion
+          matrix[i - 1][j] + 1
+          // deletion
+        );
+      }
+    }
+  }
+  return matrix[b.length][a.length];
+}
+function similarity(a, b) {
+  const aLower = a.toLowerCase();
+  const bLower = b.toLowerCase();
+  if (aLower === bLower) return 1;
+  if (bLower.startsWith(aLower) || aLower.startsWith(bLower)) {
+    return 0.9;
+  }
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  const distance = levenshteinDistance(aLower, bLower);
+  return 1 - distance / maxLen;
+}
+function findSimilarTrait(input, threshold = 0.5) {
+  let bestMatch;
+  let bestScore = threshold;
+  for (const trait of VR_TRAITS) {
+    const score = similarity(input, trait);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = trait;
+    }
+  }
+  return bestMatch;
+}
+function findSimilarKeyword(input, threshold = 0.5) {
+  const keywords = [
+    "composition",
+    "object",
+    "template",
+    "spatial_group",
+    "environment",
+    "state",
+    "logic",
+    "on_click",
+    "on_hover",
+    "on_enter",
+    "on_exit",
+    "position",
+    "rotation",
+    "scale",
+    "color",
+    "model",
+    "geometry",
+    "visible",
+    "opacity",
+    "material",
+    "physics",
+    "audio",
+    "animation",
+    "true",
+    "false",
+    "null",
+    "if",
+    "else",
+    "for",
+    "while",
+    "function",
+    "let",
+    "const",
+    "return",
+    "import",
+    "from",
+    "using",
+    "spawn",
+    "emit"
+  ];
+  let bestMatch;
+  let bestScore = threshold;
+  for (const keyword of keywords) {
+    const score = similarity(input, keyword);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = keyword;
+    }
+  }
+  return bestMatch;
+}
+function getSourceContext(source, line, column, contextLines = 2) {
+  const lines = source.split("\n");
+  const result = [];
+  const startLine = Math.max(1, line - contextLines);
+  const endLine = Math.min(lines.length, line + contextLines);
+  const maxLineNum = endLine;
+  const padding = String(maxLineNum).length;
+  for (let i = startLine; i <= endLine; i++) {
+    const lineContent = lines[i - 1] || "";
+    const lineNum = String(i).padStart(padding, " ");
+    const prefix = i === line ? ">" : " ";
+    result.push(`${prefix} ${lineNum} | ${lineContent}`);
+    if (i === line) {
+      const indicator = " ".repeat(padding + 4 + Math.max(0, column - 1)) + "^";
+      result.push(indicator);
+    }
+  }
+  return result.join("\n");
+}
+function createRichError(code, message, line, column, options = {}) {
+  const { source, suggestion, severity = "error", endLine, endColumn } = options;
+  return {
+    code,
+    message: `${code}: ${message}`,
+    line,
+    column,
+    endLine,
+    endColumn,
+    context: source ? getSourceContext(source, line, column) : void 0,
+    suggestion,
+    severity
+  };
+}
+function createTraitError(traitName, line, column, source) {
+  const similar = findSimilarTrait(traitName);
+  const suggestion = similar ? `Did you mean '@${similar}'?` : void 0;
+  return createRichError("HSP200", `Unknown trait '@${traitName}'`, line, column, {
+    source,
+    suggestion
+  });
+}
+function createKeywordError(found, expected, line, column, source) {
+  const similar = findSimilarKeyword(found);
+  const suggestion = similar ? `Did you mean '${similar}'?` : `Expected '${expected}'`;
+  return createRichError("HSP003", `Expected '${expected}' but found '${found}'`, line, column, {
+    source,
+    suggestion
+  });
+}
+function formatRichError(error) {
+  const lines = [];
+  const icon = error.severity === "error" ? "\u274C" : error.severity === "warning" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
+  lines.push(`${icon} ${error.message}`);
+  lines.push(`   at line ${error.line}, column ${error.column}`);
+  if (error.context) {
+    lines.push("");
+    lines.push(error.context);
+  }
+  if (error.suggestion) {
+    lines.push("");
+    lines.push(`\u{1F4A1} ${error.suggestion}`);
+  }
+  lines.push("");
+  lines.push(`\u{1F4D6} See: https://holoscript.net/errors/${error.code}`);
+  return lines.join("\n");
+}
+function formatRichErrors(errors) {
+  if (errors.length === 0) {
+    return "\u2705 No errors found";
+  }
+  const lines = [];
+  const errorCount = errors.filter((e) => e.severity === "error").length;
+  const warningCount = errors.filter((e) => e.severity === "warning").length;
+  lines.push(`Found ${errorCount} error(s) and ${warningCount} warning(s):`);
+  lines.push("");
+  const displayErrors = errors.slice(0, 10);
+  for (let i = 0; i < displayErrors.length; i++) {
+    lines.push(`[${i + 1}/${errors.length}] \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    lines.push(formatRichError(displayErrors[i]));
+    lines.push("");
+  }
+  if (errors.length > 10) {
+    lines.push(`... and ${errors.length - 10} more errors`);
+  }
+  return lines.join("\n");
+}
+function getErrorCodeDocumentation() {
+  const docs = [];
+  for (const [code, description] of Object.entries(HSPLUS_ERROR_CODES)) {
+    let category = "General";
+    const num = parseInt(code.replace("HSP", ""), 10);
+    if (num < 100) category = "Syntax";
+    else if (num < 200) category = "Structure";
+    else if (num < 300) category = "Traits";
+    else if (num < 400) category = "Expressions";
+    else if (num < 500) category = "Imports";
+    else if (num >= 900) category = "Limits";
+    docs.push({ code, description, category });
+  }
+  return docs;
+}
+
+// src/parser/HoloScriptPlusParser.ts
+var Lexer = class {
+  constructor(source) {
+    this.pos = 0;
+    this.line = 1;
+    this.column = 1;
+    this.indentStack = [0];
+    this.tokens = [];
+    this.pendingDedents = 0;
+    this.source = source;
+  }
+  tokenize() {
+    while (this.pos < this.source.length) {
+      while (this.pendingDedents > 0) {
+        this.tokens.push(this.createToken("DEDENT", ""));
+        this.pendingDedents--;
+      }
+      const char = this.source[this.pos];
+      if (char === " " || char === "	") {
+        if (this.column === 1) {
+          this.handleIndentation();
+        } else {
+          this.advance();
+        }
+        continue;
+      }
+      if (char === "/" && this.peek(1) === "/") {
+        this.skipLineComment();
+        continue;
+      }
+      if (char === "\n") {
+        this.advance();
+        this.tokens.push(this.createToken("NEWLINE", "\n"));
+        this.line++;
+        this.column = 1;
+        continue;
+      }
+      if (char === "\r") {
+        const startOff = this.pos;
+        this.advance();
+        if (this.peek() === "\n") {
+          this.advance();
+        }
+        const token = this.createToken("NEWLINE", "\n");
+        token.offset = startOff;
+        this.tokens.push(token);
+        this.line++;
+        this.column = 1;
+        continue;
+      }
+      if (char === "{") {
+        this.advance();
+        this.tokens.push(this.createToken("LBRACE", "{"));
+        continue;
+      }
+      if (char === "}") {
+        this.advance();
+        this.tokens.push(this.createToken("RBRACE", "}"));
+        continue;
+      }
+      if (char === "[") {
+        this.advance();
+        this.tokens.push(this.createToken("LBRACKET", "["));
+        continue;
+      }
+      if (char === "]") {
+        this.advance();
+        this.tokens.push(this.createToken("RBRACKET", "]"));
+        continue;
+      }
+      if (char === "(") {
+        this.advance();
+        this.tokens.push(this.createToken("LPAREN", "("));
+        continue;
+      }
+      if (char === ")") {
+        this.advance();
+        this.tokens.push(this.createToken("RPAREN", ")"));
+        continue;
+      }
+      if (char === ":") {
+        this.advance();
+        this.tokens.push(this.createToken("COLON", ":"));
+        continue;
+      }
+      if (char === ",") {
+        this.advance();
+        this.tokens.push(this.createToken("COMMA", ","));
+        continue;
+      }
+      if (char === "@") {
+        this.advance();
+        this.tokens.push(this.createToken("AT", "@"));
+        continue;
+      }
+      if (char === "#") {
+        this.advance();
+        this.tokens.push(this.createToken("HASH", "#"));
+        continue;
+      }
+      if (char === ".") {
+        if (this.peek(1) === "." && this.peek(2) === ".") {
+          const startCol = this.column;
+          this.advance();
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("SPREAD", "..."));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("DOT", "."));
+        continue;
+      }
+      if (char === "+") {
+        this.advance();
+        this.tokens.push(this.createToken("PLUS", "+"));
+        continue;
+      }
+      if (char === "-") {
+        if (this.peek(1) === ">") {
+          const startCol = this.column;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("ARROW", "->"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("MINUS", "-"));
+        continue;
+      }
+      if (char === "*") {
+        this.advance();
+        this.tokens.push(this.createToken("ASTERISK", "*"));
+        continue;
+      }
+      if (char === "/") {
+        if (this.peek(1) === "*") {
+          this.skipBlockComment();
+          continue;
+        }
+        if (this.peek(1) === "/") {
+          this.skipLineComment();
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("SLASH", "/"));
+        continue;
+      }
+      if (char === "%") {
+        this.advance();
+        this.tokens.push(this.createToken("PERCENT", "%"));
+        continue;
+      }
+      if (char === "!") {
+        if (this.peek(1) === "=") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("NOT_EQUALS", "!="));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("EXCLAMATION", "!"));
+        continue;
+      }
+      if (char === "=") {
+        if (this.peek(1) === ">") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("ARROW", "=>"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        if (this.peek(1) === "=") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("DOUBLE_EQUALS", "=="));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("EQUALS", "="));
+        continue;
+      }
+      if (char === "<") {
+        if (this.peek(1) === "=") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("LESS_EQUAL", "<="));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("LESS_THAN", "<"));
+        continue;
+      }
+      if (char === ">") {
+        if (this.peek(1) === "=") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("GREATER_EQUAL", ">="));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("GREATER_THAN", ">"));
+        continue;
+      }
+      if (char === "-") {
+        if (this.peek(1) === ">") {
+          const startCol = this.column;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("ARROW", "->"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          continue;
+        }
+      }
+      if (char === "&") {
+        if (this.peek(1) === "&") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("AND", "&&"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        continue;
+      }
+      if (char === "|") {
+        if (this.peek(1) === "|") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("OR", "||"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("PIPE", "|"));
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        this.tokens.push(this.readString(char));
+        continue;
+      }
+      if (this.isDigit(char) || char === "-" && this.isDigit(this.peek(1))) {
+        this.tokens.push(this.readNumber());
+        continue;
+      }
+      if (char === "?") {
+        if (this.peek(1) === "?") {
+          if (this.peek(2) === "=") {
+            const startCol2 = this.column;
+            const startOff2 = this.pos;
+            this.advance();
+            this.advance();
+            this.advance();
+            this.tokens.push(this.createToken("NULL_COALESCE_ASSIGN", "??="));
+            this.tokens[this.tokens.length - 1].column = startCol2;
+            this.tokens[this.tokens.length - 1].offset = startOff2;
+            continue;
+          }
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("NULL_COALESCE", "??"));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        if (this.peek(1) === ".") {
+          const startCol = this.column;
+          const startOff = this.pos;
+          this.advance();
+          this.advance();
+          this.tokens.push(this.createToken("OPTIONAL_DOT", "?."));
+          this.tokens[this.tokens.length - 1].column = startCol;
+          this.tokens[this.tokens.length - 1].offset = startOff;
+          continue;
+        }
+        this.advance();
+        this.tokens.push(this.createToken("QUESTION", "?"));
+        continue;
+      }
+      if (char === "`") {
+        this.tokens.push(this.readTemplateString());
+        continue;
+      }
+      if (this.isIdentifierStart(char)) {
+        this.tokens.push(this.readIdentifier());
+        continue;
+      }
+      this.advance();
+    }
+    while (this.indentStack.length > 1) {
+      this.tokens.push(this.createToken("DEDENT", ""));
+      this.indentStack.pop();
+    }
+    this.tokens.push(this.createToken("EOF", ""));
+    return this.tokens;
+  }
+  advance() {
+    const char = this.source[this.pos];
+    this.pos++;
+    this.column++;
+    return char;
+  }
+  peek(offset = 0) {
+    const pos = this.pos + offset;
+    return pos < this.source.length ? this.source[pos] : "";
+  }
+  createToken(type, value) {
+    const token = {
+      type,
+      value,
+      line: this.line,
+      column: this.column - (value.length || 0),
+      offset: this.pos - (value.length || 0)
+    };
+    return token;
+  }
+  handleIndentation() {
+    let indent = 0;
+    while (this.peek() === " " || this.peek() === "	") {
+      indent += this.peek() === "	" ? 4 : 1;
+      this.advance();
+    }
+    if (this.peek() === "\n" || this.peek() === "\r") {
+      return;
+    }
+    const currentIndent = this.indentStack[this.indentStack.length - 1];
+    if (indent > currentIndent) {
+      this.indentStack.push(indent);
+      this.tokens.push(this.createToken("INDENT", ""));
+    } else if (indent < currentIndent) {
+      while (this.indentStack.length > 1 && indent < this.indentStack[this.indentStack.length - 1]) {
+        this.indentStack.pop();
+        this.pendingDedents++;
+      }
+    }
+  }
+  skipLineComment() {
+    while (this.peek() !== "\n" && this.pos < this.source.length) {
+      this.advance();
+    }
+  }
+  skipBlockComment() {
+    this.advance();
+    this.advance();
+    while (this.pos < this.source.length) {
+      if (this.peek() === "*" && this.peek(1) === "/") {
+        this.advance();
+        this.advance();
+        break;
+      }
+      if (this.peek() === "\n") {
+        this.line++;
+        this.column = 0;
+      }
+      this.advance();
+    }
+  }
+  readString(quote) {
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.advance();
+    let value = "";
+    while (this.peek() !== quote && this.pos < this.source.length) {
+      if (this.peek() === "\\") {
+        this.advance();
+        const escaped = this.advance();
+        switch (escaped) {
+          case "n":
+            value += "\n";
+            break;
+          case "t":
+            value += "	";
+            break;
+          case "r":
+            value += "\r";
+            break;
+          case "\\":
+            value += "\\";
+            break;
+          case '"':
+            value += '"';
+            break;
+          case "'":
+            value += "'";
+            break;
+          default:
+            value += escaped;
+        }
+      } else if (this.peek() === "\n") {
+        this.line++;
+        this.column = 0;
+        value += this.advance();
+      } else {
+        value += this.advance();
+      }
+    }
+    this.advance();
+    const token = {
+      type: "STRING",
+      value,
+      line: startLine,
+      column: startColumn,
+      offset: this.pos - (value.length + 2)
+      // approximation for start of string
+    };
+    return token;
+  }
+  readTemplateString() {
+    const startLine = this.line;
+    const startColumn = this.column;
+    const startOff = this.pos;
+    this.advance();
+    let value = "";
+    let braceDepth = 0;
+    while (this.pos < this.source.length) {
+      const c = this.source[this.pos];
+      if (c === "`" && braceDepth === 0) {
+        this.advance();
+        break;
+      }
+      if (c === "$" && this.peek(1) === "{") {
+        braceDepth++;
+        value += "${";
+        this.advance();
+        this.advance();
+        continue;
+      }
+      if (c === "{" && braceDepth > 0) {
+        braceDepth++;
+        value += c;
+        this.advance();
+        continue;
+      }
+      if (c === "}" && braceDepth > 0) {
+        braceDepth--;
+        value += c;
+        this.advance();
+        continue;
+      }
+      if (c === "\n") {
+        this.line++;
+        this.column = 0;
+      }
+      value += c;
+      this.advance();
+    }
+    return {
+      type: "TEMPLATE_STRING",
+      value,
+      line: startLine,
+      column: startColumn,
+      offset: startOff
+    };
+  }
+  readNumber() {
+    const startColumn = this.column;
+    let value = "";
+    if (this.peek() === "-") {
+      value += this.advance();
+    }
+    while (this.isDigit(this.peek())) {
+      value += this.advance();
+    }
+    if (this.peek() === "." && this.isDigit(this.peek(1))) {
+      value += this.advance();
+      while (this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+    if (this.peek() === "e" || this.peek() === "E") {
+      value += this.advance();
+      if (this.peek() === "+" || this.peek() === "-") {
+        value += this.advance();
+      }
+      while (this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+    while (this.isAlpha(this.peek()) || this.peek() === "%") {
+      value += this.advance();
+    }
+    const token = {
+      type: "NUMBER",
+      value,
+      line: this.line,
+      column: startColumn,
+      offset: this.pos - value.length
+    };
+    return token;
+  }
+  readExpression() {
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.advance();
+    this.advance();
+    let value = "";
+    let braceDepth = 1;
+    while (braceDepth > 0 && this.pos < this.source.length) {
+      if (this.peek() === "{") {
+        braceDepth++;
+      } else if (this.peek() === "}") {
+        braceDepth--;
+        if (braceDepth === 0) {
+          break;
+        }
+      }
+      if (this.peek() === "\n") {
+        this.line++;
+        this.column = 0;
+      }
+      value += this.advance();
+    }
+    this.advance();
+    return {
+      type: "EXPRESSION",
+      value: value.trim(),
+      line: startLine,
+      column: startColumn,
+      offset: this.pos - (value.length + 3)
+      // ${...}
+    };
+  }
+  readIdentifier() {
+    const startColumn = this.column;
+    let value = "";
+    while (this.isIdentifierPart(this.peek())) {
+      value += this.advance();
+    }
+    if (value === "true" || value === "false") {
+      return {
+        type: "BOOLEAN",
+        value,
+        line: this.line,
+        column: startColumn,
+        offset: this.pos - value.length
+      };
+    }
+    if (value === "null" || value === "none") {
+      return {
+        type: "NULL",
+        value,
+        line: this.line,
+        column: startColumn,
+        offset: this.pos - value.length
+      };
+    }
+    const token = {
+      type: "IDENTIFIER",
+      value,
+      line: this.line,
+      column: startColumn,
+      offset: this.pos - value.length
+    };
+    switch (value) {
+      case "state_machine":
+        token.type = "STATE_MACHINE";
+        break;
+      case "initial":
+        token.type = "INITIAL";
+        break;
+      case "state":
+        token.type = "STATE";
+        break;
+      case "on_entry":
+        token.type = "ON_ENTRY";
+        break;
+      case "on_exit":
+        token.type = "ON_EXIT";
+        break;
+      case "transition":
+        token.type = "TRANSITION";
+        break;
+      case "match":
+        token.type = "MATCH";
+        break;
+      case "on_error":
+        token.type = "ON_ERROR";
+        break;
+      case "assert":
+        token.type = "ASSERT";
+        break;
+      case "_":
+        token.type = "UNDERSCORE";
+        break;
+    }
+    return token;
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  isAlpha(char) {
+    return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+  }
+  isIdentifierStart(char) {
+    return this.isAlpha(char) || char === "_" || char === "$";
+  }
+  isIdentifierPart(char) {
+    return this.isIdentifierStart(char) || this.isDigit(char) || char === "-";
+  }
+};
+var HoloScriptPlusParser = class {
+  constructor(options = {}) {
+    this.tokens = [];
+    this.pos = 0;
+    this.source = "";
+    this.errors = [];
+    this.warnings = [];
+    this.imports = [];
+    this.hasState = false;
+    this.hasVRTraits = false;
+    this.hasControlFlow = false;
+    this.compiledExpressions = /* @__PURE__ */ new Map();
+    this.errorRecovery = new ErrorRecovery();
+    /**
+     * Internal incremental parser for parseIncremental.
+     * Uses ChunkBasedIncrementalParser with AST-aware chunking and
+     * dependency tracking — no fallback to full re-parse for unchanged chunks.
+     */
+    this._incrementalParser = null;
+    /**
+     * Per-cache incremental parser map so callers can supply their own cache
+     * and still get a dedicated ChunkBasedIncrementalParser instance.
+     */
+    this._incrementalParserCache = /* @__PURE__ */ new Map();
+    this.options = {
+      enableVRTraits: true,
+      enableTypeScriptImports: true,
+      strict: false,
+      ...options
+    };
+  }
+  /**
+   * Get quick fixes for all errors in the last parse
+   * Useful for IDE integrations and LSP
+   */
+  getQuickFixes() {
+    const fixes = /* @__PURE__ */ new Map();
+    for (const error of this.errors) {
+      const errorFixes = generateQuickFixes(
+        {
+          code: error.code,
+          message: error.message,
+          line: error.line,
+          column: error.column,
+          source: this.source
+        },
+        this.source
+      );
+      if (errorFixes.length > 0) {
+        fixes.set(error.line, errorFixes);
+      }
+    }
+    return fixes;
+  }
+  /**
+   * Get enriched errors with additional suggestions from ErrorRecovery
+   */
+  getEnrichedErrors() {
+    return this.errors.map(
+      (error) => enrichErrorWithSuggestions(
+        {
+          code: error.code,
+          message: error.message,
+          line: error.line,
+          column: error.column,
+          source: this.source
+        },
+        this.source
+      )
+    );
+  }
+  parse(source) {
+    this.source = source;
+    this.errors = [];
+    this.warnings = [];
+    this.imports = [];
+    this.hasState = false;
+    this.hasVRTraits = false;
+    this.hasControlFlow = false;
+    this.compiledExpressions = /* @__PURE__ */ new Map();
+    this.pos = 0;
+    this.errorRecovery.clear();
+    const lexer = new Lexer(source);
+    this.tokens = lexer.tokenize();
+    const root = this.parseDocument();
+    return this.buildResult(root);
+  }
+  /**
+   * Performs an incremental parse using ChunkBasedIncrementalParser with
+   * AST-aware chunking, hash-based caching, and dependency tracking.
+   *
+   * Unchanged chunks are served from cache (zero re-parse cost). Only chunks
+   * whose content hash changed — plus chunks that reference changed ones via
+   * `using`, spread, or `@composition` — are re-parsed.
+   *
+   * Previous implementation fell back to a full re-parse per chunk because it
+   * used `ChunkDetector.detect()` inline without the stateful comparison that
+   * `ChunkBasedIncrementalParser` provides. This is now wired through the
+   * superior engine (APL WIT audit gap #3, 2026-05-21).
+   */
+  parseIncremental(source, cache = globalParseCache) {
+    let incrementalParser = this._incrementalParserCache.get(cache);
+    if (!incrementalParser) {
+      incrementalParser = new ChunkBasedIncrementalParser(cache);
+      this._incrementalParserCache.set(cache, incrementalParser);
+    }
+    const incrementalResult = incrementalParser.parse(source);
+    const chunks = ChunkDetector.detect(source);
+    const children = incrementalResult.ast.type === "fragment" ? incrementalResult.ast.children || [] : [incrementalResult.ast];
+    for (let i = 0; i < children.length; i++) {
+      const chunk = chunks[i];
+      if (chunk && chunk.startLine > 1) {
+        this.offsetNodeLoc(children[i], chunk.startLine - 1);
+      }
+    }
+    this.source = source;
+    this.errors = [];
+    this.warnings = [];
+    this.imports = [];
+    this.hasState = false;
+    this.hasVRTraits = false;
+    this.hasControlFlow = false;
+    this.compiledExpressions = /* @__PURE__ */ new Map();
+    for (const node of children) {
+      if (node && typeof node === "object") {
+        const nodeAny = node;
+        if (nodeAny.traits instanceof Map) {
+          for (const [traitName] of nodeAny.traits) {
+            const name = String(traitName);
+            if (name === "state") this.hasState = true;
+            if (name === "grabbable" || name === "throwable" || name === "hoverable" || name === "clickable" || name === "collidable") {
+              this.hasVRTraits = true;
+            }
+          }
+        }
+      }
+    }
+    const root = incrementalResult.ast.type === "fragment" ? incrementalResult.ast : {
+      type: "fragment",
+      id: "root",
+      properties: {},
+      directives: [],
+      children: [incrementalResult.ast],
+      traits: /* @__PURE__ */ new Map(),
+      loc: incrementalResult.ast.loc || { start: { line: 1, column: 1 }, end: { line: 1, column: 1 } },
+      body: [incrementalResult.ast]
+    };
+    if (root.type === "fragment" && root.loc) {
+      root.loc.start = { line: 1, column: 1 };
+      if (chunks.length > 0) {
+        root.loc.end = { line: chunks[chunks.length - 1].endLine, column: 1 };
+      }
+    }
+    const result = this.buildResult(root);
+    result.incrementalMetrics = {
+      cached: incrementalResult.cached,
+      parsed: incrementalResult.parsed,
+      duration: incrementalResult.duration,
+      changedChunks: incrementalResult.changedChunks
+    };
+    return result;
+  }
+  buildResult(root) {
+    const isFragment = root.type === "fragment";
+    const directives = root.directives || [];
+    let version;
+    const migrations = [];
+    for (const d of directives) {
+      if (d.type === "version") {
+        version = d.version;
+      } else if (d.type === "migrate") {
+        migrations.push({
+          type: "Migration",
+          fromVersion: d.fromVersion,
+          body: d.body
+        });
+      }
+    }
+    if (version === void 0) version = "1.0";
+    const children = isFragment ? root.children || [] : [root];
+    const worlds = children.filter((c) => c.type === "world");
+    const compositions = children.filter((c) => c.type === "composition");
+    const templates = children.filter((c) => c.type === "template");
+    const npcs = children.filter((c) => c.type === "npc");
+    const ast = {
+      type: "Program",
+      id: "root",
+      properties: isFragment ? root.properties || {} : {},
+      directives,
+      children,
+      worlds,
+      compositions,
+      templates,
+      npcs,
+      traits: isFragment ? root.traits || /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(),
+      loc: root.loc,
+      body: children,
+      version,
+      migrations: migrations.length > 0 ? migrations : void 0,
+      root,
+      imports: this.imports,
+      hasState: this.hasState,
+      hasVRTraits: this.hasVRTraits,
+      hasControlFlow: this.hasControlFlow
+    };
+    return {
+      success: this.errors.length === 0,
+      ast,
+      compiledExpressions: this.compiledExpressions,
+      requiredCompanions: this.imports.map((i) => i.path),
+      features: {
+        state: this.hasState,
+        vrTraits: this.hasVRTraits,
+        loops: this.hasControlFlow,
+        conditionals: this.hasControlFlow,
+        lifecycleHooks: (root.directives || []).some((d) => d.type === "lifecycle")
+      },
+      warnings: this.warnings,
+      errors: this.errors
+    };
+  }
+  offsetNodeLoc(node, lineOffset) {
+    if (node.loc) {
+      if (node.loc.start) node.loc.start.line += lineOffset;
+      if (node.loc.end) node.loc.end.line += lineOffset;
+    }
+    if (node.children) {
+      node.children.forEach((child) => this.offsetNodeLoc(child, lineOffset));
+    }
+    if (node.body && Array.isArray(node.body)) {
+      node.body.forEach((child) => this.offsetNodeLoc(child, lineOffset));
+    }
+  }
+  parseDocument() {
+    this.skipNewlines();
+    const topLevelNodes = [];
+    const globalDirectives = [];
+    while (!this.check("EOF")) {
+      const currentDirectives = [];
+      try {
+        while (this.check("AT")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            const { type } = directive;
+            if (type === "version" || type === "migrate" || type === "import" || type === "export") {
+              globalDirectives.push(directive);
+              if (type === "export") {
+                currentDirectives.push(directive);
+              }
+            } else {
+              currentDirectives.push(directive);
+            }
+          }
+          this.skipNewlines();
+        }
+        const isNodeStart = this.check("IDENTIFIER") || this.check("STATE_MACHINE") || this.check("STATE") || this.check("TRANSITION") || this.check("INITIAL");
+        if (isNodeStart) {
+          const node = this.parseNode();
+          const existingDirectives = node.directives || [];
+          node.directives = [...currentDirectives, ...existingDirectives];
+          if (node.type === "template") {
+            for (const d of currentDirectives) {
+              if (d.type === "version") {
+                node.version = d.version;
+              } else if (d.type === "migrate") {
+                if (!node.migrations) node.migrations = [];
+                node.migrations.push({
+                  type: "Migration",
+                  fromVersion: d.fromVersion,
+                  body: d.body
+                });
+              }
+            }
+          }
+          topLevelNodes.push(node);
+        } else {
+          if (currentDirectives.length > 0) {
+            if (this.check("EOF")) {
+              globalDirectives.push(...currentDirectives);
+            } else {
+              this.error(
+                `Expected node after directives, got ${this.current().type}. Valid nodes: orb, template, logic, object, world, composition, scene, group`,
+                "HSP003"
+              );
+              globalDirectives.push(...currentDirectives);
+            }
+          } else if (!this.check("EOF")) {
+            this.error(
+              `Unexpected token ${this.current().type} "${this.current().value}" at top level. Expected: composition, object, world, template, logic, or @directive`,
+              "HSP001"
+            );
+            throw new Error("ParseError");
+          }
+        }
+        if (this.check("IDENTIFIER") && this.current().value === "connect") {
+          const connection = this.parseConnectionStatement();
+          const node = {
+            type: "connection",
+            properties: connection,
+            directives: [],
+            children: [],
+            traits: /* @__PURE__ */ new Map(),
+            loc: {
+              start: { line: this.current().line, column: 0 },
+              end: { line: this.current().line, column: 0 }
+            }
+          };
+          topLevelNodes.push(node);
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        if (errorMessage !== "ParseError" && errorMessage !== "Unexpected token") {
+          console.error(e);
+        }
+        this.synchronize();
+      }
+      this.skipNewlines();
+    }
+    if (topLevelNodes.length === 1 && globalDirectives.length === 0) {
+      return topLevelNodes[0];
+    }
+    return {
+      type: "fragment",
+      id: "root",
+      properties: {},
+      directives: globalDirectives,
+      children: topLevelNodes,
+      traits: /* @__PURE__ */ new Map(),
+      loc: {
+        start: { line: 1, column: 1 },
+        end: { line: this.current().line, column: this.current().column }
+      },
+      body: topLevelNodes
+    };
+  }
+  parseNode() {
+    const startToken = this.current();
+    const typeToken = this.match([
+      "IDENTIFIER",
+      "STATE_MACHINE",
+      "STATE",
+      "TRANSITION",
+      "INITIAL",
+      "ON_ENTRY",
+      "ON_EXIT"
+    ]) || this.expect("IDENTIFIER", "Expected element type");
+    const type = typeToken.value;
+    if (type === "template") {
+      const templateName = this.expect("STRING", "Expected template name").value;
+      const templateBody = this.parseBlockContent();
+      let version;
+      const migrations = [];
+      const directives2 = [];
+      const children2 = [];
+      for (const [key, value] of Object.entries(templateBody)) {
+        if (key === "@version") {
+          const v = value;
+          if (v.type === "version") version = v.version;
+          delete templateBody[key];
+        } else if (key === "@migrate") {
+          const m = value;
+          if (m.type === "migrate") {
+            migrations.push({
+              type: "Migration",
+              fromVersion: m.fromVersion,
+              body: m.body
+            });
+          }
+          delete templateBody[key];
+        } else if (key.startsWith("@")) {
+          directives2.push(value);
+          delete templateBody[key];
+        } else if (typeof value === "object" && value && "type" in value) {
+          children2.push(value);
+          delete templateBody[key];
+        }
+      }
+      return {
+        type: "template",
+        name: templateName,
+        properties: templateBody,
+        // Now contains only true properties
+        version,
+        migrations,
+        directives: directives2,
+        children: children2,
+        traits: /* @__PURE__ */ new Map(),
+        loc: {
+          start: { line: startToken.line, column: startToken.column },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
+    if (type === "logic") {
+      const logicBody = this.parseLogicBlock();
+      return {
+        type: "logic",
+        name: "logic",
+        id: "logic",
+        properties: {},
+        directives: [],
+        children: [],
+        traits: /* @__PURE__ */ new Map(),
+        body: logicBody,
+        loc: {
+          start: { line: startToken.line, column: startToken.column },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
+    if ([
+      "module",
+      "script",
+      "struct",
+      "enum",
+      "class",
+      "interface",
+      "action",
+      "function",
+      "async",
+      "on"
+    ].includes(type)) {
+      let name = "anonymous";
+      if (this.check("IDENTIFIER")) {
+        name = this.advance().value;
+      } else if (this.check("STRING")) {
+        name = this.advance().value;
+      }
+      while (this.check("DOT")) {
+        this.advance();
+        if (this.check("IDENTIFIER")) this.advance();
+      }
+      if (this.check("LPAREN")) {
+        this.skipParens();
+      }
+      let bodyContent = "";
+      if (this.check("LBRACE")) {
+        bodyContent = this.parseRawBlock();
+      }
+      return {
+        type,
+        name,
+        id: name,
+        properties: {},
+        directives: [],
+        children: [],
+        traits: /* @__PURE__ */ new Map(),
+        body: bodyContent,
+        loc: {
+          start: { line: startToken.line, column: startToken.column },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
+    if (startToken.type === "STATE_MACHINE" || type === "state_machine") {
+      return this.parseStateMachine();
+    }
+    if (type === "on_error" || startToken.type === "ON_ERROR") {
+      return this.parseOnErrorNode();
+    }
+    if (type === "assert" || startToken.type === "ASSERT") {
+      return this.parseAssertNode();
+    }
+    if (type === "environment") {
+      const envBody = this.parseEnvironmentBlock();
+      return {
+        type: "environment",
+        properties: envBody.properties,
+        directives: envBody.directives,
+        children: [],
+        traits: /* @__PURE__ */ new Map(),
+        loc: {
+          start: { line: startToken.line, column: startToken.column },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
+    if (type === "composition" || type === "world") {
+      let id2;
+      if (this.check("HASH")) {
+        this.advance();
+        id2 = this.expect("IDENTIFIER", "Expected ID after #").value;
+      }
+      if (this.check("STRING")) {
+        id2 = this.advance().value;
+      }
+      if (this.check("IDENTIFIER")) {
+        id2 = this.advance().value;
+      }
+      const compBody = this.parseCompositionBlock();
+      const traits2 = /* @__PURE__ */ new Map();
+      for (const child of compBody.children) {
+        if (child.type === "fragment" && Array.isArray(child.directives)) {
+          for (const d of child.directives) {
+            if (d.type === "trait") {
+              traits2.set(d.name, d.config);
+              this.hasVRTraits = true;
+            }
+          }
+        }
+      }
+      return {
+        type: type === "composition" ? "composition" : "world",
+        name: id2,
+        id: id2,
+        properties: compBody.properties || {},
+        directives: [],
+        children: compBody.children,
+        traits: traits2,
+        body: compBody,
+        loc: {
+          start: { line: startToken.line, column: startToken.column },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
+    let id;
+    let templateRef;
+    if (this.check("HASH")) {
+      this.advance();
+      id = this.expect("IDENTIFIER", "Expected ID after #").value;
+    }
+    if (this.check("STRING")) {
+      id = this.advance().value;
+    }
+    if (this.check("IDENTIFIER") && this.current().value !== "using") {
+      id = this.advance().value;
+    }
+    if (this.check("LPAREN")) {
+      this.skipParens();
+    }
+    if (this.check("IDENTIFIER") && this.current().value === "using") {
+      this.advance();
+      templateRef = this.expect("STRING", "Expected template name after using").value;
+    }
+    if (this.check("COLON")) {
+      this.advance();
+      if (this.check("IDENTIFIER")) this.advance();
+      if (this.check("LBRACKET")) {
+        this.advance();
+        if (this.check("RBRACKET")) this.advance();
+      }
+    }
+    const properties = {};
+    const children = [];
+    const directives = [];
+    const traits = /* @__PURE__ */ new Map();
+    if (templateRef) {
+      properties.__templateRef = templateRef;
+    }
+    while (!this.check("LBRACE") && !this.check("EOF")) {
+      try {
+        if (this.check("NEWLINE")) {
+          this.skipNewlines();
+          if (this.check("LBRACE")) break;
+          if (!this.check("AT")) {
+            if (this.check("EOF")) break;
+          }
+        }
+        if (this.check("AT")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            if (directive.type === "trait") {
+              traits.set(directive.name, directive.config);
+              this.hasVRTraits = true;
+              directives.push(directive);
+            } else {
+              directives.push(directive);
+            }
+          }
+        } else if (this.check("SPREAD")) {
+          const startToken2 = this.advance();
+          const targetExpr = this.parseUnary();
+          let target;
+          if (typeof targetExpr === "object" && targetExpr && "__ref" in targetExpr) {
+            target = targetExpr.__ref;
+          } else if (typeof targetExpr === "string") {
+            target = targetExpr;
+          } else {
+            this.error(
+              "Expected identifier or member expression after spread operator (...)",
+              "HSP002"
+            );
+            target = "unknown";
+          }
+          children.push({
+            type: "spread",
+            target,
+            loc: {
+              start: { line: startToken2.line, column: startToken2.column },
+              end: { line: this.current().line, column: this.current().column }
+            }
+          });
+        } else if (this.check("IDENTIFIER")) {
+          const key = this.advance().value;
+          let value = true;
+          if (this.check("COLON")) {
+            this.advance();
+            value = this.parseValue();
+          }
+          properties[key] = value;
+        } else {
+          if (!this.check("LBRACE")) {
+            this.error(
+              `Unexpected token in properties: ${this.current().type}. Expected property name, @directive, or spread (...)`,
+              "HSP101"
+            );
+            this.synchronizeProperty();
+          }
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        if (errorMessage !== "ParseError") console.error(e);
+        this.synchronizeProperty();
+      }
+    }
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        try {
+          this.skipNewlines();
+          if (this.check("RBRACE") || this.check("EOF")) break;
+          if (this.check("AT")) {
+            const directive = this.parseDirective();
+            if (directive) {
+              if (directive.type === "trait") {
+                traits.set(directive.name, directive.config);
+                this.hasVRTraits = true;
+              }
+              directives.push(directive);
+            }
+          } else if (this.check("SPREAD")) {
+            const startToken2 = this.advance();
+            const targetExpr = this.parseUnary();
+            let target;
+            if (typeof targetExpr === "object" && targetExpr && "__ref" in targetExpr) {
+              target = targetExpr.__ref;
+            } else if (typeof targetExpr === "string") {
+              target = targetExpr;
+            } else {
+              this.error(
+                "Expected identifier or member expression after spread operator (...)",
+                "HSP002"
+              );
+              target = "unknown";
+            }
+            const spreadNode = {
+              type: "spread",
+              target,
+              loc: {
+                start: { line: startToken2.line, column: startToken2.column },
+                end: { line: this.current().line, column: this.current().column }
+              }
+            };
+            children.push(spreadNode);
+            const key = "__spread_" + target;
+            properties[key] = spreadNode;
+          } else {
+            const token = this.current();
+            const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "HASH" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
+            if (isKeyToken) {
+              const saved = this.pos;
+              const name = this.advance().value;
+              const childNodeKeywords = [
+                "logic",
+                "template",
+                "environment",
+                "state",
+                "object",
+                "composition",
+                "system",
+                "core_config",
+                "narrative",
+                "quest",
+                "objective",
+                "dialogue",
+                "choice",
+                "visual_metadata",
+                "spatial_group",
+                "scene",
+                "group",
+                "world",
+                "module",
+                "struct",
+                "orb",
+                "on_error",
+                "assert",
+                "transition",
+                "on_entry",
+                "on_exit",
+                "page",
+                "include"
+              ];
+              if (name === "transition" && this.check("STRING")) {
+                const event = this.advance().value;
+                if (this.check("ARROW")) {
+                  this.advance();
+                  const targetState = this.expect("STRING", "Expected target state string").value;
+                  let block = {};
+                  if (this.check("LBRACE")) {
+                    block = this.parseBlockContent();
+                  }
+                  children.push({
+                    type: "transition",
+                    name: `${event}_to_${targetState}`,
+                    event,
+                    target: targetState,
+                    guard: block.guard || "",
+                    action: block.action || "",
+                    block
+                  });
+                  continue;
+                } else {
+                  this.pos = saved;
+                }
+              }
+              if (name === "on_entry" || name === "on_exit") {
+                let block = "";
+                if (this.check("LBRACE")) {
+                  block = this.parseCodeBlock();
+                } else {
+                  while (!this.check("RBRACE") && !this.check("EOF")) this.advance();
+                }
+                children.push({
+                  type: "method",
+                  name,
+                  params: [],
+                  returnType: "unknown",
+                  body: block
+                });
+                continue;
+              }
+              if (this.check("LPAREN")) {
+                const possibleMethod = saved;
+                this.pos = saved;
+                const methodName = this.advance().value;
+                const params = [];
+                this.advance();
+                while (!this.check("RPAREN") && !this.check("EOF") && !this.check("LBRACE")) {
+                  if (this.check("IDENTIFIER")) {
+                    params.push(this.advance().value);
+                  } else {
+                    this.advance();
+                  }
+                }
+                if (this.check("RPAREN")) this.advance();
+                let returnType = "unknown";
+                if (this.check("COLON")) {
+                  this.advance();
+                  if (this.check("IDENTIFIER")) {
+                    returnType = this.advance().value;
+                  }
+                }
+                if (this.check("LBRACE")) {
+                  const body = this.parseCodeBlock();
+                  children.push({
+                    type: "method",
+                    name: methodName,
+                    params,
+                    returnType,
+                    body
+                  });
+                  continue;
+                } else {
+                  this.pos = possibleMethod;
+                  this.advance();
+                }
+              }
+              if (this.check("COLON") || this.check("EQUALS")) {
+                this.advance();
+                properties[name] = this.parseValue();
+              } else if (childNodeKeywords.includes(name) && (this.check("LBRACE") || this.check("STRING"))) {
+                this.pos = saved;
+                children.push(this.parseNode());
+              } else if (this.current().type === "IDENTIFIER") {
+                this.pos = saved;
+                children.push(this.parseNode());
+              } else {
+                properties[name] = true;
+                while (this.check("LPAREN") || this.check("DOT") || this.check("LBRACE")) {
+                  if (this.check("LPAREN")) this.skipParens();
+                  else if (this.check("LBRACE")) this.skipBraces();
+                  else {
+                    this.advance();
+                    if (this.check("IDENTIFIER")) this.advance();
+                  }
+                }
+              }
+            } else if (this.check("COMMA")) {
+              this.advance();
+            } else {
+              this.error(
+                `Unexpected token ${this.current().type} "${this.current().value}" in node body`
+              );
+              this.synchronizeProperty();
+            }
+          }
+          this.skipNewlines();
+        } catch (e) {
+          const errorMessage = e instanceof Error ? e.message : String(e);
+          if (errorMessage !== "ParseError") console.error(e);
+          this.synchronizeProperty();
+        }
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return {
+      type,
+      name: id,
+      // Mapping id to name for runtime compatibility
+      id,
+      properties,
+      directives,
+      children,
+      traits,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  parseDirective() {
+    this.expect("AT", "Expected @");
+    const nameToken = this.current();
+    const isKeyword = ["STATE_MACHINE", "STATE", "ON_ENTRY", "ON_EXIT", "TRANSITION"].includes(
+      nameToken.type
+    );
+    if (nameToken.type !== "IDENTIFIER" && !isKeyword) {
+      this.error(
+        `Expected directive name, got ${nameToken.type}. Directives start with @ followed by name (e.g., @grabbable)`,
+        "HSP201"
+      );
+      return null;
+    }
+    this.advance();
+    const name = nameToken.value;
+    if (name === "version") {
+      this.expect("LPAREN", "Expected ( after @version");
+      const versionToken = this.expect("NUMBER", "Expected version number");
+      const version = Number(versionToken.value);
+      this.expect("RPAREN", "Expected ) after version number");
+      return { type: "version", version };
+    }
+    if (name === "migrate") {
+      const fromToken = this.expect("IDENTIFIER", 'Expected "from" after @migrate');
+      if (fromToken.value !== "from") {
+        this.error('Expected "from" after @migrate');
+      }
+      this.expect("LPAREN", "Expected ( after from");
+      const fromVersionToken = this.expect("NUMBER", "Expected version number");
+      const fromVersion = Number(fromVersionToken.value);
+      this.expect("RPAREN", "Expected ) after version number");
+      const body = this.check("LBRACE") ? this.parseCodeBlock() : "";
+      return { type: "migrate", fromVersion, body };
+    }
+    if (VR_TRAITS.includes(name)) {
+      if (!this.options.enableVRTraits) {
+        this.warn(`VR trait @${name} is disabled`);
+        return null;
+      }
+      let config2 = {};
+      if (this.check("LPAREN")) {
+        config2 = this.parseTraitConfig();
+      } else if (this.check("LBRACE")) {
+        config2 = this.parseBlockContent();
+      }
+      return this.parseTraitSumTail({ type: "trait", name, config: config2 });
+    }
+    if (LIFECYCLE_HOOKS.includes(name)) {
+      const params = [];
+      if (this.check("LPAREN")) {
+        this.advance();
+        while (!this.check("RPAREN") && !this.check("EOF")) {
+          params.push(this.expect("IDENTIFIER", "Expected parameter name").value);
+          if (this.check("COLON")) {
+            this.advance();
+            this.expect("IDENTIFIER", "Expected type");
+          }
+          if (this.check("COMMA")) this.advance();
+        }
+        this.expect("RPAREN", "Expected )");
+      }
+      if (this.check("COLON")) {
+        this.advance();
+        if (this.check("LPAREN")) this.skipParens();
+        if (this.check("ARROW")) this.advance();
+      }
+      let body = "";
+      if (this.check("ARROW")) {
+        this.advance();
+        body = this.parseInlineExpression();
+      } else if (this.check("LBRACE")) {
+        body = this.parseCodeBlock();
+      }
+      return {
+        type: "lifecycle",
+        hook: name,
+        params,
+        body
+      };
+    }
+    if (name === "state") {
+      this.hasState = true;
+      const body = this.parseStateBlock();
+      return { type: "state", body };
+    }
+    if (name === "bindings") {
+      const bindings = this.parseBindingsBlock();
+      return { type: "bindings", bindings };
+    }
+    if (name === "for") {
+      this.hasControlFlow = true;
+      const variable = this.expect("IDENTIFIER", "Expected variable name").value;
+      this.expect("IDENTIFIER", 'Expected "in"');
+      const iterable = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: "for", variable, iterable, body };
+    }
+    if (name === "forEach") {
+      this.hasControlFlow = true;
+      const variable = this.expect("IDENTIFIER", "Expected variable name").value;
+      this.expect("IDENTIFIER", 'Expected "in"');
+      const collection = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: "forEach", variable, collection, body };
+    }
+    if (name === "while") {
+      this.hasControlFlow = true;
+      const condition = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: "while", condition, body };
+    }
+    if (name === "if") {
+      this.hasControlFlow = true;
+      const condition = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      let elseBody;
+      this.skipNewlines();
+      if (this.check("AT")) {
+        const saved = this.pos;
+        this.advance();
+        if (this.check("IDENTIFIER") && this.current().value === "else") {
+          this.advance();
+          elseBody = this.parseControlFlowBody();
+        } else {
+          this.pos = saved;
+        }
+      }
+      return { type: "if", condition, body, else: elseBody };
+    }
+    if (name === "import") {
+      if (!this.options.enableTypeScriptImports) {
+        this.warn("@import is disabled");
+        return null;
+      }
+      let namedImports;
+      let isWildcard = false;
+      if (this.check("LBRACE")) {
+        this.advance();
+        namedImports = [];
+        while (!this.check("RBRACE") && !this.check("EOF")) {
+          if (this.check("IDENTIFIER")) {
+            namedImports.push(this.advance().value);
+          }
+          if (this.check("COMMA")) this.advance();
+        }
+        this.expect("RBRACE", "Expected } in named import list");
+        if (this.check("IDENTIFIER") && this.current().value === "from") {
+          this.advance();
+        } else {
+          this.warn("Expected 'from' after named import specifiers");
+        }
+      }
+      if (this.check("ASTERISK") || this.check("IDENTIFIER") && this.current().value === "*") {
+        this.advance();
+        isWildcard = true;
+        if (this.check("IDENTIFIER") && this.current().value === "as") {
+          this.advance();
+        }
+      }
+      const path = this.expect("STRING", "Expected import path string").value;
+      let alias = path.split("/").pop()?.replace(/\.[^.]+$/, "") || "import";
+      if (!namedImports && this.check("IDENTIFIER") && this.current().value === "as") {
+        this.advance();
+        alias = this.expect("IDENTIFIER", "Expected alias after as").value;
+      }
+      if (isWildcard && this.check("IDENTIFIER") && this.current().value !== "from") {
+        alias = this.advance().value;
+        if (this.check("IDENTIFIER") && this.current().value === "from") {
+          this.advance();
+        }
+      }
+      this.imports.push({ path, alias, namedImports, isWildcard });
+      return {
+        type: "import",
+        path,
+        alias,
+        namedImports,
+        isWildcard
+      };
+    }
+    if (name === "export") {
+      let exportKind = "any";
+      if (this.check("IDENTIFIER")) {
+        const kindToken = this.current();
+        const knownKinds = ["template", "object", "composition", "trait", "group", "scene"];
+        if (knownKinds.includes(kindToken.value)) {
+          exportKind = this.advance().value;
+        }
+      }
+      let exportName;
+      if (this.check("STRING")) {
+        exportName = this.advance().value;
+      } else if (this.check("IDENTIFIER")) {
+        exportName = this.advance().value;
+      }
+      return {
+        type: "export",
+        exportKind,
+        exportName
+      };
+    }
+    if (name === "manifest") {
+      let config2 = {};
+      let manifestName = "default";
+      if (this.check("LPAREN")) {
+        this.advance();
+        if (this.check("STRING")) {
+          manifestName = this.advance().value;
+        }
+        while (!this.check("RPAREN") && !this.check("EOF")) this.advance();
+        this.expect("RPAREN", "Expected )");
+      } else if (this.check("STRING")) {
+        manifestName = this.advance().value;
+      }
+      if (this.check("LBRACE")) {
+        const block = this.parseBlockContent();
+        config2 = { ...config2, ...block };
+      }
+      return { type: "manifest", name: manifestName, ...config2 };
+    }
+    if (name === "asset") {
+      if (this.check("LPAREN")) {
+        const config2 = this.parseTraitConfig();
+        return { ...config2, type: "asset" };
+      }
+      const assetId = this.expect("STRING", "Expected asset ID").value;
+      return { type: "asset", id: assetId };
+    }
+    if (name === "semantic") {
+      const semanticName = this.check("LPAREN") ? this.parseParenString() : this.expect("STRING", "Expected semantic name").value;
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "semantic", name: semanticName };
+    }
+    if (name === "annotate") {
+      const annotateName = this.check("LPAREN") ? this.parseParenString() : this.expect("STRING", "Expected annotation type").value;
+      let config2 = {};
+      if (this.check("COMMA")) {
+        this.advance();
+        config2 = this.parseValue();
+        if (this.check("RPAREN")) this.advance();
+      } else if (this.check("RPAREN")) {
+        this.advance();
+      }
+      return { type: "annotate", annotationType: annotateName, config: config2 };
+    }
+    if (name === "semantic_ref") {
+      const refName = this.check("LPAREN") ? this.parseParenString() : this.expect("STRING", "Expected semantic reference").value;
+      return { type: "semantic_ref", ref: refName };
+    }
+    if (name === "bindings") {
+      const bindings = this.parseBindingsBlock();
+      return { type: "bindings", bindings };
+    }
+    if (name === "world_metadata") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "world_metadata" };
+    }
+    if (name === "world_config") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "world_config" };
+    }
+    if (name === "zones") {
+      const zones = this.parseNamedBlockList("zone");
+      return { type: "zones", zones };
+    }
+    if (name === "spawn_points") {
+      const spawns = this.parseNamedBlockList("spawn");
+      return { type: "spawn_points", spawns };
+    }
+    if (name === "skybox") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "skybox" };
+    }
+    if (name === "ambient_light") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "ambient_light" };
+    }
+    if (name === "directional_light") {
+      let lightName = "default";
+      if (this.check("LPAREN")) {
+        lightName = this.parseParenString();
+      }
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "directional_light", name: lightName };
+    }
+    if (name === "fog") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "fog" };
+    }
+    if (name === "artwork_metadata") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "artwork_metadata" };
+    }
+    if (name === "npc_behavior") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "npc_behavior" };
+    }
+    if (name === "interactive") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "interactive" };
+    }
+    if (name === "lod") {
+      const config2 = this.parseBlockContent();
+      return { ...config2, type: "lod" };
+    }
+    if (name === "external_api") {
+      let externalApiName = "default";
+      if (this.check("STRING")) {
+        externalApiName = this.advance().value;
+      } else if (this.check("IDENTIFIER")) {
+        externalApiName = this.advance().value;
+      }
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.parseTraitConfig();
+      return {
+        type: "external_api",
+        name: externalApiName,
+        ...config2
+      };
+    }
+    if (name === "generate") {
+      const config2 = this.parseTraitConfig();
+      const prompt = config2.prompt || "";
+      const context = config2.context || "";
+      const target = config2.target || "children";
+      return { type: "generate", prompt, context, target };
+    }
+    if (name === "npc") {
+      const npcName = this.expect("STRING", "Expected NPC name").value;
+      const props = this.parsePropsBlock();
+      return { type: "npc", name: npcName, props };
+    }
+    if (name === "dialog") {
+      const dialogName = this.expect("STRING", "Expected dialog name").value;
+      const { props, options } = this.parseDialogBlock();
+      return { type: "dialog", name: dialogName, props, options };
+    }
+    if (name === "hololand") {
+      if (this.check("DOT")) {
+        this.advance();
+        const eventName = this.expect("IDENTIFIER", "Expected event name").value;
+        const params = [];
+        if (this.check("LPAREN")) {
+          this.advance();
+          while (!this.check("RPAREN") && !this.check("EOF")) {
+            params.push(this.expect("IDENTIFIER", "Expected parameter").value);
+            if (this.check("COLON")) {
+              this.advance();
+              this.expect("IDENTIFIER", "Expected type");
+            }
+            if (this.check("COMMA")) this.advance();
+          }
+          this.expect("RPAREN", "Expected )");
+        }
+        return { type: "hololand_event", event: eventName, params };
+      }
+    }
+    if (STRUCTURAL_DIRECTIVES.includes(name)) {
+      let nodeName;
+      if (this.check("STRING")) {
+        nodeName = this.advance().value;
+      }
+      const config2 = this.check("LBRACE") ? this.parseBlockContent() : this.parseTraitConfig();
+      return { ...config2, type: name, name: nodeName };
+    }
+    if (this.options.strict) {
+      this.traitError(name);
+    } else {
+      this.warn(`Unknown directive @${name}`);
+    }
+    let config = {};
+    if (this.check("LPAREN")) {
+      config = this.parseTraitConfig();
+    } else if (this.check("LBRACE")) {
+      config = this.parseBlockContent();
+    }
+    if (this.check("COLON")) {
+      this.advance();
+      if (this.check("LPAREN")) this.skipParens();
+      if (this.check("ARROW")) this.advance();
+      if (this.check("LBRACE")) {
+        config.body = this.parseCodeBlock();
+      }
+    }
+    return this.parseTraitSumTail({ type: "trait", name, config });
+  }
+  parseTraitSumTail(first) {
+    if (!this.check("PLUS")) {
+      return first;
+    }
+    const alternatives = [
+      { type: "trait_atom", name: first.name, config: first.config ?? {} }
+    ];
+    while (this.check("PLUS")) {
+      this.advance();
+      alternatives.push(this.parseTraitAtom());
+    }
+    return {
+      type: "trait_sum",
+      operation: "additive",
+      alternatives
+    };
+  }
+  parseTraitAtom() {
+    this.expect("AT", "Expected @ in trait sum alternative");
+    const name = this.expect("IDENTIFIER", "Expected trait name in trait sum alternative").value;
+    let config = {};
+    if (this.check("LPAREN")) {
+      config = this.parseTraitConfig();
+    } else if (this.check("LBRACE")) {
+      config = this.parseBlockContent();
+    }
+    return { type: "trait_atom", name, config };
+  }
+  /**
+   * Parse a string inside parentheses: ("name")
+   */
+  parseParenString() {
+    this.expect("LPAREN", "Expected (");
+    const value = this.expect("STRING", "Expected string").value;
+    this.expect("RPAREN", "Expected )");
+    return value;
+  }
+  parseConnectionStatement() {
+    this.expect("IDENTIFIER", "Expected connect");
+    const from = this.expect("IDENTIFIER", "Expected from name").value;
+    this.expect("IDENTIFIER", "Expected to");
+    const to = this.expect("IDENTIFIER", "Expected to name").value;
+    return { from, to };
+  }
+  /**
+   * Parse block content: { key: value, ... }
+   */
+  parseBlockContent() {
+    const content = {};
+    if (!this.check("LBRACE")) {
+      return content;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      const token = this.current();
+      const isKeyToken = token.type === "IDENTIFIER" || token.type === "STRING" || token.type === "STATE" || token.type === "STATE_MACHINE" || token.type === "INITIAL" || token.type === "ON_ENTRY" || token.type === "ON_EXIT" || token.type === "TRANSITION";
+      if (isKeyToken) {
+        const next = this.peek(1);
+        if (next.type === "COLON" || next.type === "EQUALS") {
+          const key = this.advance().value;
+          this.advance();
+          content[key] = this.parseValue();
+        } else if (next.type === "STRING" || next.type === "LBRACE" || next.type === "IDENTIFIER") {
+          const node = this.parseNode();
+          const type = node.type;
+          const name = node.name || `unnamed_${type}_${Object.keys(content).length}`;
+          content[name] = node;
+        } else {
+          const key = this.advance().value;
+          content[key] = true;
+        }
+      } else if (this.check("SPREAD")) {
+        this.advance();
+        const val = this.parseValue();
+        const spreadKey = `__spread_${Object.keys(content).length}`;
+        content[spreadKey] = { type: "spread", argument: val };
+      } else if (this.check("AT")) {
+        const directive = this.parseDirective();
+        if (directive) {
+          const dirKey = ("name" in directive ? directive.name : void 0) || directive.type;
+          content[`@${dirKey}`] = directive;
+        }
+      } else if (this.check("LBRACE")) {
+        let depth = 1;
+        this.advance();
+        while (depth > 0 && !this.check("EOF")) {
+          if (this.check("LBRACE")) depth++;
+          if (this.check("RBRACE")) depth--;
+          this.advance();
+        }
+      } else if (this.check("LPAREN")) {
+        this.skipParens();
+      } else {
+        this.advance();
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return content;
+  }
+  /**
+   * Parse bindings block: { bind(expr) -> target, ... }
+   */
+  parseBindingsBlock() {
+    const bindings = [];
+    if (!this.check("LBRACE")) {
+      return bindings;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("IDENTIFIER") && this.current().value === "bind") {
+        this.advance();
+        if (this.check("LPAREN")) {
+          this.advance();
+          let source = "";
+          let parenDepth = 1;
+          while (parenDepth > 0 && !this.check("EOF")) {
+            if (this.check("LPAREN")) parenDepth++;
+            if (this.check("RPAREN")) {
+              parenDepth--;
+              if (parenDepth === 0) break;
+            }
+            source += this.advance().value + " ";
+          }
+          this.expect("RPAREN", "Expected )");
+          source = source.trim();
+          if (this.check("ARROW")) {
+            this.advance();
+          }
+          let target = "";
+          while (!this.check("NEWLINE") && !this.check("RBRACE") && !this.check("EOF")) {
+            target += this.advance().value;
+          }
+          target = target.trim();
+          bindings.push({ source, target });
+        }
+      } else {
+        while (!this.check("NEWLINE") && !this.check("RBRACE") && !this.check("EOF")) {
+          this.advance();
+        }
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return bindings;
+  }
+  /**
+   * Parse named block list: zone "name" { ... } or spawn "name" { ... }
+   */
+  parseNamedBlockList(blockType) {
+    const blocks = [];
+    if (!this.check("LBRACE")) {
+      return blocks;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("IDENTIFIER") && this.current().value === blockType) {
+        this.advance();
+        const blockName = this.expect("STRING", `Expected ${blockType} name`).value;
+        const config = this.parseBlockContent();
+        blocks.push({ name: blockName, config });
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return blocks;
+  }
+  /**
+   * Parse composition block: composition "Name" { ... }
+   */
+  parseCompositionBlock() {
+    const result = {
+      systems: [],
+      configs: [],
+      children: [],
+      properties: {}
+    };
+    if (!this.check("LBRACE")) {
+      return result;
+    }
+    this.advance();
+    this.skipNewlines();
+    const childNodeKeywords = [
+      "logic",
+      "template",
+      "environment",
+      "state",
+      "object",
+      "composition",
+      "system",
+      "core_config",
+      "narrative",
+      "quest",
+      "objective",
+      "dialogue",
+      "choice",
+      "visual_metadata",
+      "spatial_group",
+      "scene",
+      "group",
+      "world",
+      "module",
+      "struct",
+      "orb",
+      "on_error",
+      "assert",
+      "topic",
+      "channel",
+      "config",
+      "zone",
+      "audio",
+      "light",
+      "npc",
+      "camera",
+      "timeline",
+      "page",
+      "include"
+    ];
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      const currentDirectives = [];
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      while (this.check("AT")) {
+        const directive = this.parseDirective();
+        if (directive) {
+          currentDirectives.push(directive);
+        }
+        this.skipNewlines();
+      }
+      const isNodeStart = this.check("IDENTIFIER") || this.check("STATE_MACHINE") || this.check("STATE") || this.check("TRANSITION") || this.check("INITIAL");
+      if (isNodeStart) {
+        const token = this.current();
+        const next = this.peek(1);
+        if (token.type === "IDENTIFIER" && token.value === "system" && (next.type === "IDENTIFIER" || next.type === "STRING") && this.peek(2).type !== "LBRACE") {
+          const startToken = this.advance();
+          const name = this.advance().value;
+          result.systems.push({
+            type: "system",
+            name,
+            id: name,
+            properties: {},
+            directives: currentDirectives,
+            children: [],
+            traits: /* @__PURE__ */ new Map(),
+            loc: {
+              start: { line: startToken.line, column: startToken.column },
+              end: { line: this.current().line, column: this.current().column }
+            }
+          });
+        } else if (token.type === "IDENTIFIER" && token.value === "page" && next.type === "STRING") {
+          const startToken = this.advance();
+          const name = this.advance().value;
+          const properties = {};
+          if (this.check("LBRACE")) {
+            this.advance();
+            this.skipNewlines();
+            while (!this.check("RBRACE") && !this.check("EOF")) {
+              this.skipNewlines();
+              if (this.check("RBRACE") || this.check("EOF")) break;
+              if (this.check("IDENTIFIER")) {
+                const key = this.advance().value;
+                if (this.check("COLON") || this.check("EQUALS")) {
+                  this.advance();
+                  properties[key] = this.parseValue();
+                } else if (this.check("STRING")) {
+                  properties[key] = this.advance().value;
+                } else {
+                  properties[key] = true;
+                }
+              } else if (this.check("COMMA")) {
+                this.advance();
+              } else {
+                this.advance();
+              }
+              this.skipNewlines();
+            }
+            this.expect("RBRACE", "Expected }");
+          }
+          result.children.push({
+            type: "page",
+            name,
+            id: name,
+            properties,
+            directives: currentDirectives,
+            children: [],
+            traits: /* @__PURE__ */ new Map(),
+            loc: {
+              start: { line: startToken.line, column: startToken.column },
+              end: { line: this.current().line, column: this.current().column }
+            }
+          });
+        } else if (next.type === "COLON" || next.type === "EQUALS") {
+          const key = this.advance().value;
+          this.advance();
+          result.properties[key] = this.parseValue();
+        } else if (childNodeKeywords.includes(token.value) && (next.type === "LBRACE" || next.type === "STRING" || next.type === "IDENTIFIER" || next.type === "HASH")) {
+          const keyword = this.current().value;
+          const node = this.parseNode();
+          node.directives = [...currentDirectives, ...node.directives || []];
+          if (keyword === "system" || node.type === "system") {
+            result.systems.push(node);
+          } else if (keyword === "core_config" || node.type === "core_config") {
+            result.configs.push(node);
+          } else {
+            result.children.push(node);
+          }
+        } else if (!childNodeKeywords.includes(token.value) && (next.type === "STRING" || next.type === "NUMBER" || next.type === "BOOLEAN" || next.type === "NULL")) {
+          const key = this.advance().value;
+          result.properties[key] = this.parseValue();
+        } else if (next.type === "LBRACE" || next.type === "IDENTIFIER" || next.type === "STRING" || next.type === "HASH") {
+          const keyword = this.current().value;
+          const node = this.parseNode();
+          node.directives = [...currentDirectives, ...node.directives || []];
+          if (keyword === "system" || node.type === "system") {
+            result.systems.push(node);
+          } else if (keyword === "core_config" || node.type === "core_config") {
+            result.configs.push(node);
+          } else {
+            result.children.push(node);
+          }
+        } else if (next.type === "LPAREN") {
+          const possibleMethod = this.pos;
+          const methodName = this.advance().value;
+          const params = [];
+          this.advance();
+          while (!this.check("RPAREN") && !this.check("EOF") && !this.check("LBRACE")) {
+            if (this.check("IDENTIFIER")) {
+              params.push(this.advance().value);
+            } else {
+              this.advance();
+            }
+          }
+          if (this.check("RPAREN")) this.advance();
+          let returnType = "unknown";
+          if (this.check("COLON")) {
+            this.advance();
+            if (this.check("IDENTIFIER")) {
+              returnType = this.advance().value;
+            }
+          }
+          if (this.check("LBRACE")) {
+            const body = this.parseCodeBlock();
+            result.children.push({
+              type: "method",
+              name: methodName,
+              params,
+              returnType,
+              body
+            });
+          } else {
+            this.pos = possibleMethod;
+            const key = this.advance().value;
+            result.properties[key] = true;
+          }
+        } else {
+          const key = this.advance().value;
+          result.properties[key] = true;
+        }
+      } else if (currentDirectives.length > 0) {
+        const fragment = {
+          type: "fragment",
+          directives: currentDirectives,
+          children: [],
+          traits: /* @__PURE__ */ new Map(),
+          properties: {}
+        };
+        result.children.push(fragment);
+      } else if (this.check("COMMA")) {
+        this.advance();
+      } else if (this.check("LBRACKET")) {
+        let depth = 1;
+        this.advance();
+        while (depth > 0 && !this.check("EOF")) {
+          if (this.check("LBRACKET")) depth++;
+          else if (this.check("RBRACKET")) depth--;
+          this.advance();
+        }
+      } else if (this.check("LBRACE")) {
+        let depth = 1;
+        this.advance();
+        while (depth > 0 && !this.check("EOF")) {
+          if (this.check("LBRACE")) depth++;
+          else if (this.check("RBRACE")) depth--;
+          this.advance();
+        }
+      } else {
+        if (!this.check("RBRACE") && !this.check("EOF")) {
+          this.error(
+            `Unexpected token ${this.current().type} "${this.current().value}" in composition body. Expected property name, @directive, or child node`,
+            "HSP101"
+          );
+          this.advance();
+        }
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return result;
+  }
+  /**
+   * Parse logic block: logic { function..., on_tick..., on_scene_load... }
+   */
+  parseLogicBlock() {
+    const result = {
+      functions: [],
+      actions: [],
+      eventHandlers: [],
+      tickHandlers: []
+    };
+    if (!this.check("LBRACE")) {
+      return result;
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("IDENTIFIER")) {
+        const keyword = this.current().value;
+        if (keyword === "function") {
+          this.advance();
+          const funcName = this.expect("IDENTIFIER", "Expected function name").value;
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN") && !this.check("EOF")) {
+              params.push(this.expect("IDENTIFIER", "Expected parameter").value);
+              if (this.check("COLON")) {
+                this.advance();
+                this.expect("IDENTIFIER", "Expected type");
+              }
+              if (this.check("COMMA")) this.advance();
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          if (this.check("COLON")) {
+            this.advance();
+            this.expect("IDENTIFIER", "Expected return type");
+          }
+          const body = this.parseCodeBlock();
+          result.functions.push({ name: funcName, params, body });
+        } else if (keyword === "action") {
+          this.advance();
+          const actionName = this.check("IDENTIFIER") || this.check("STRING") ? this.advance().value : "anonymous";
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN") && !this.check("EOF")) {
+              if (this.check("IDENTIFIER")) {
+                params.push(this.advance().value);
+                if (this.check("COLON")) {
+                  this.advance();
+                  while (!this.check("COMMA") && !this.check("RPAREN") && !this.check("EOF")) {
+                    this.advance();
+                  }
+                }
+                if (this.check("COMMA")) {
+                  this.advance();
+                }
+              } else {
+                this.advance();
+              }
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.check("LBRACE") ? this.parseCodeBlock() : "";
+          result.actions.push({ name: actionName, params, body });
+        } else if (keyword === "on_tick") {
+          this.advance();
+          let interval = 1;
+          if (this.check("LPAREN")) {
+            this.advance();
+            const intervalToken = this.expect("NUMBER", "Expected interval");
+            interval = parseFloat(intervalToken.value);
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.parseCodeBlock();
+          result.tickHandlers.push({ interval, body });
+        } else if (keyword === "on_scene_load") {
+          this.advance();
+          const body = this.parseCodeBlock();
+          result.eventHandlers.push({ event: "scene_load", params: [], body });
+        } else if (keyword === "on") {
+          this.advance();
+          let eventName = "";
+          if (this.check("AT")) {
+            this.advance();
+            eventName = this.expect("IDENTIFIER", "Expected event namespace").value;
+            if (this.check("DOT")) {
+              this.advance();
+              eventName += "." + this.expect("IDENTIFIER", "Expected event name").value;
+            }
+          } else {
+            eventName = this.expect("IDENTIFIER", "Expected event name").value;
+          }
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN") && !this.check("EOF")) {
+              params.push(this.expect("IDENTIFIER", "Expected parameter").value);
+              if (this.check("COLON")) {
+                this.advance();
+                this.expect("IDENTIFIER", "Expected type");
+              }
+              if (this.check("COMMA")) this.advance();
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.parseCodeBlock();
+          result.eventHandlers.push({ event: eventName, params, body });
+        } else if (keyword === "on_start") {
+          this.advance();
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            while (!this.check("RPAREN") && !this.check("EOF")) {
+              params.push(this.expect("IDENTIFIER", "Expected parameter").value);
+              if (this.check("COMMA")) this.advance();
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.parseCodeBlock();
+          result.eventHandlers.push({ event: "start", params, body });
+        } else if (keyword === "on_event") {
+          this.advance();
+          let eventName = "";
+          const params = [];
+          if (this.check("LPAREN")) {
+            this.advance();
+            if (this.check("STRING")) {
+              eventName = this.advance().value;
+            } else {
+              eventName = this.expect("IDENTIFIER", "Expected event name").value;
+            }
+            if (this.check("COMMA")) {
+              this.advance();
+              while (!this.check("RPAREN") && !this.check("EOF")) {
+                params.push(this.expect("IDENTIFIER", "Expected parameter").value);
+                if (this.check("COMMA")) this.advance();
+              }
+            }
+            this.expect("RPAREN", "Expected )");
+          }
+          const body = this.parseCodeBlock();
+          result.eventHandlers.push({ event: eventName, params, body });
+        } else {
+          this.advance();
+          if (this.check("LPAREN")) this.skipParens();
+          if (this.check("LBRACE")) this.skipBraces();
+          while (!this.check("RBRACE") && !this.check("EOF") && !this.check("NEWLINE")) {
+            this.advance();
+          }
+        }
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return result;
+  }
+  /**
+   * Parse environment block with lighting directives
+   */
+  parseEnvironmentBlock() {
+    const properties = {};
+    const directives = [];
+    if (!this.check("LBRACE")) {
+      return { properties, directives };
+    }
+    this.advance();
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("AT")) {
+        const directive = this.parseDirective();
+        if (directive) {
+          directives.push(directive);
+        }
+      } else if (this.check("IDENTIFIER")) {
+        const key = this.advance().value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          properties[key] = this.parseValue();
+        } else {
+          properties[key] = true;
+        }
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return { properties, directives };
+  }
+  parsePropsBlock() {
+    this.skipNewlines();
+    const props = {};
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        if (this.check("SPREAD")) {
+          this.advance();
+          const val = this.parseValue();
+          const spreadKey = `__spread_${Object.keys(props).length}`;
+          props[spreadKey] = { type: "spread", argument: val };
+          this.skipNewlines();
+          if (this.check("COMMA")) this.advance();
+          this.skipNewlines();
+          continue;
+        }
+        const key = this.expect("IDENTIFIER", "Expected property name").value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          props[key] = this.parseValue();
+        } else {
+          props[key] = true;
+        }
+        this.skipNewlines();
+        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return props;
+  }
+  parseDialogBlock() {
+    this.skipNewlines();
+    const props = {};
+    const options = [];
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        if (this.check("IDENTIFIER") && this.current().value === "option") {
+          this.advance();
+          const text = this.expect("STRING", "Expected option text").value;
+          this.expect("ARROW", "Expected ->");
+          let target;
+          if (this.check("AT")) {
+            const d = this.parseDirective();
+            target = { type: "directive", value: d };
+          } else {
+            target = this.expect("STRING", "Expected target ID").value;
+          }
+          options.push({ text, target });
+        } else {
+          const key = this.expect("IDENTIFIER", "Expected property name").value;
+          if (this.check("COLON") || this.check("EQUALS")) {
+            this.advance();
+            props[key] = this.parseValue();
+          } else {
+            props[key] = true;
+          }
+        }
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return { props, options };
+  }
+  parseTraitConfig() {
+    const config = {};
+    if (this.check("LPAREN")) {
+      this.advance();
+      this.skipNewlines();
+      if (this.check("STRING") && (this.peek(1).type === "RPAREN" || this.peek(1).type === "COMMA")) {
+        config["default"] = this.advance().value;
+        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
+      }
+      while (!this.check("RPAREN") && !this.check("EOF")) {
+        this.skipNewlines();
+        if (this.check("RPAREN") || this.check("EOF")) break;
+        if (!this.check("IDENTIFIER")) {
+          this.advance();
+          continue;
+        }
+        const key = this.expect("IDENTIFIER", "Expected property name").value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          config[key] = this.parseValue();
+        } else {
+          config[key] = true;
+        }
+        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
+      }
+      this.expect("RPAREN", "Expected )");
+    }
+    return config;
+  }
+  parseStateBlock() {
+    const state = {};
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("EOF")) break;
+        if (this.check("SPREAD")) {
+          this.advance();
+          const spreadArg = this.parseValue();
+          if (spreadArg === null) {
+            this.error("Expected expression after spread operator (...) in state block", "HSP300");
+          } else {
+            const spreadKey = `__spread_${Object.keys(state).length}`;
+            state[spreadKey] = { type: "spread", argument: spreadArg };
+          }
+          this.skipNewlines();
+          continue;
+        }
+        const key = this.expect("IDENTIFIER", "Expected state variable name").value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          state[key] = this.parseValue();
+        } else {
+          state[key] = true;
+        }
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return state;
+  }
+  /**
+   * Parse spatial state machine (Phase 13)
+   */
+  parseStateMachine() {
+    const startToken = this.current();
+    if (startToken.type === "STATE_MACHINE") {
+      this.advance();
+    }
+    const name = this.expect("IDENTIFIER", "Expected state machine name").value;
+    const states = [];
+    const transitions = [];
+    let initialState = "";
+    this.expect("LBRACE", "Expected { after state machine name");
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      const current = this.current();
+      if (current.type === "INITIAL" || current.value === "initial") {
+        this.advance();
+        this.expect("COLON", "Expected : after initial");
+        initialState = this.expect("STRING", "Expected initial state name").value;
+      } else if (current.type === "STATE" || current.value === "state") {
+        states.push(this.parseStateNode());
+      } else if (current.type === "TRANSITION" || current.value === "transitions") {
+        transitions.push(...this.parseTransitionsBlock());
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected } at end of state machine");
+    return {
+      type: "state-machine",
+      name,
+      initialState,
+      states,
+      transitions,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  parseStateNode() {
+    this.advance();
+    const name = this.expect("IDENTIFIER", "Expected state name").value;
+    let onEntry;
+    let onExit;
+    this.expect("LBRACE", "Expected { after state name");
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      const current = this.current();
+      if (current.type === "ON_ENTRY" || current.value === "on_entry") {
+        this.advance();
+        onEntry = this.parseCodeBlock();
+      } else if (current.type === "ON_EXIT" || current.value === "on_exit") {
+        this.advance();
+        onExit = this.parseCodeBlock();
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return { name, onEntry, onExit };
+  }
+  parseOnErrorNode() {
+    const startToken = this.previous();
+    const body = this.parseControlFlowBody();
+    return {
+      type: "on_error",
+      body,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  parseAssertNode() {
+    const startToken = this.previous();
+    this.expect("LPAREN", "Expected (");
+    const condition = this.parseExpression();
+    let message = "";
+    if (this.match(["COMMA"])) {
+      message = String(this.parseValue());
+    }
+    this.expect("RPAREN", "Expected )");
+    return {
+      type: "assert",
+      condition,
+      message,
+      loc: {
+        start: { line: startToken.line, column: startToken.column },
+        end: { line: this.current().line, column: this.current().column }
+      }
+    };
+  }
+  parseTransitionsBlock() {
+    const transitions = [];
+    this.advance();
+    this.expect("LBRACE", "Expected {");
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      const from = this.expect("IDENTIFIER", "Expected source state").value;
+      this.expect("ARROW", "Expected ->");
+      const to = this.expect("IDENTIFIER", "Expected target state").value;
+      this.expect("COLON", "Expected :");
+      const event = this.expect("IDENTIFIER", "Expected event name").value;
+      transitions.push({ from, to, event });
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return transitions;
+  }
+  parseControlFlowBody() {
+    const nodes = [];
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        this.skipNewlines();
+        if (this.check("RBRACE") || this.check("EOF")) break;
+        if (this.check("AT")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            if (directive.type === "for" || directive.type === "while" || directive.type === "if" || directive.type === "forEach") {
+              nodes.push({
+                type: "fragment",
+                directives: [directive],
+                children: [],
+                traits: /* @__PURE__ */ new Map(),
+                properties: {}
+              });
+            } else if (directive.type === "trait") {
+              this.warn(`Standalone trait @${directive.name} in block`);
+            } else {
+              nodes.push({
+                type: "fragment",
+                directives: [directive],
+                children: [],
+                traits: /* @__PURE__ */ new Map(),
+                properties: {}
+              });
+            }
+          }
+        } else if (this.check("IDENTIFIER")) {
+          nodes.push(this.parseNode());
+        } else {
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return nodes;
+  }
+  parseCodeBlock() {
+    let code = "";
+    let braceDepth = 0;
+    if (this.check("LBRACE")) {
+      this.advance();
+      braceDepth = 1;
+      try {
+        while (braceDepth > 0 && !this.check("EOF")) {
+          const token = this.advance();
+          if (token.type === "LBRACE") {
+            braceDepth++;
+            code += "{";
+          } else if (token.type === "RBRACE") {
+            braceDepth--;
+            if (braceDepth > 0) {
+              code += "}";
+            }
+          } else if (token.type === "STRING") {
+            code += `"${token.value}"`;
+            code += " ";
+          } else {
+            code += token.value;
+            if (token.type === "NEWLINE") {
+              code += "\n";
+            } else {
+              code += " ";
+            }
+          }
+        }
+      } catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        if (errorMessage !== "ParseError") console.error(e);
+        this.synchronize();
+      }
+    }
+    return code.trim();
+  }
+  parseInlineExpression() {
+    let expr = "";
+    while (!this.check("NEWLINE") && !this.check("LBRACE") && !this.check("EOF")) {
+      const token = this.advance();
+      expr += token.value + " ";
+    }
+    return expr.trim();
+  }
+  /**
+   * Parse any value or expression (Entry Point)
+   * Handles operators like ?? and unary operators like ...
+   */
+  parseValue() {
+    return this.parseAssignment();
+  }
+  /**
+   * Parse assignment expressions (??=)
+   * Much lower precedence than ternary/null-coalesce
+   * Example: x ??= value  →  x = x ?? value
+   */
+  parseAssignment() {
+    const expr = this.parseExpression();
+    if (this.check("NULL_COALESCE_ASSIGN")) {
+      const isAssignable = typeof expr === "string" || typeof expr === "object" && expr && "__ref" in expr || // identifier or member expression
+      typeof expr === "object" && expr && "type" in expr && expr.type === "member";
+      if (isAssignable) {
+        this.advance();
+        const value = this.parseExpression();
+        return {
+          type: "nullCoalescingAssignment",
+          target: expr,
+          value
+        };
+      } else {
+        throw new Error(
+          `Cannot use ??= on non-assignable expression at line ${this.current().line}`
+        );
+      }
+    }
+    return expr;
+  }
+  /**
+   * Parse expression (Entry Point for operators)
+   * Handles Ternary Operators: cond ? true : false
+   */
+  parseExpression() {
+    const condition = this.parseNullCoalesce();
+    if (this.check("QUESTION")) {
+      this.advance();
+      const trueValue = this.parseExpression();
+      this.expect("COLON", "Expected : in ternary operator");
+      const falseValue = this.parseExpression();
+      return { type: "ternary", condition, trueValue, falseValue };
+    }
+    return condition;
+  }
+  /**
+   * Parse binary expressions: ?? (null coalesce) — lower precedence than logical OR
+   */
+  parseNullCoalesce() {
+    let left = this.parseLogicalOr();
+    while (this.check("NULL_COALESCE")) {
+      this.advance();
+      const right = this.parseLogicalOr();
+      left = { type: "binary", operator: "??", left, right };
+    }
+    return left;
+  }
+  /** Parse logical OR: a || b */
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.check("OR")) {
+      this.advance();
+      const right = this.parseLogicalAnd();
+      left = { type: "binary", operator: "||", left, right };
+    }
+    return left;
+  }
+  /** Parse logical AND: a && b */
+  parseLogicalAnd() {
+    let left = this.parseEquality();
+    while (this.check("AND")) {
+      this.advance();
+      const right = this.parseEquality();
+      left = { type: "binary", operator: "&&", left, right };
+    }
+    return left;
+  }
+  /** Parse equality: a == b, a != b */
+  parseEquality() {
+    let left = this.parseComparison();
+    while (this.check("DOUBLE_EQUALS") || this.check("NOT_EQUALS")) {
+      const operator = this.current().value;
+      this.advance();
+      const right = this.parseComparison();
+      left = { type: "binary", operator, left, right };
+    }
+    return left;
+  }
+  /** Parse comparison: a < b, a > b, a <= b, a >= b */
+  parseComparison() {
+    let left = this.parseAdditive();
+    while (this.check("LESS_THAN") || this.check("GREATER_THAN") || this.check("LESS_EQUAL") || this.check("GREATER_EQUAL")) {
+      const operator = this.current().value;
+      this.advance();
+      const right = this.parseAdditive();
+      left = { type: "binary", operator, left, right };
+    }
+    return left;
+  }
+  /** Parse additive: a + b, a - b */
+  parseAdditive() {
+    let left = this.parseMultiplicative();
+    while (this.check("PLUS") || this.check("MINUS")) {
+      const operator = this.current().value;
+      this.advance();
+      const right = this.parseMultiplicative();
+      left = { type: "binary", operator, left, right };
+    }
+    return left;
+  }
+  /** Parse multiplicative: a * b, a / b, a % b */
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.check("ASTERISK") || this.check("SLASH") || this.check("PERCENT")) {
+      const operator = this.current().value;
+      this.advance();
+      const right = this.parseUnary();
+      left = { type: "binary", operator, left, right };
+    }
+    return left;
+  }
+  /**
+   * Parse unary prefix expressions (!, spread, unary minus, unary plus)
+   */
+  parseUnary() {
+    if (this.check("SPREAD")) {
+      this.advance();
+      const arg = this.parseUnary();
+      return { type: "spread", argument: arg };
+    }
+    if (this.check("EXCLAMATION")) {
+      this.advance();
+      const arg = this.parseUnary();
+      return { type: "unary", operator: "!", argument: arg };
+    }
+    if (this.check("MINUS") || this.check("PLUS")) {
+      const operator = this.current().type === "MINUS" ? "-" : "+";
+      this.advance();
+      const arg = this.parseUnary();
+      if (typeof arg === "number") {
+        return operator === "-" ? -arg : arg;
+      }
+      return { type: "unary", operator, argument: arg };
+    }
+    return this.parsePrimary();
+  }
+  /**
+   * Parse a primary value (literal, identifier, parenthesis, etc.)
+   */
+  parsePrimary() {
+    const token = this.current();
+    if (token.type === "STRING") {
+      this.advance();
+      return token.value;
+    }
+    if (token.type === "NUMBER") {
+      this.advance();
+      const match = token.value.match(/^(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?)(.*)?$/i);
+      if (match) {
+        const num = parseFloat(match[1]);
+        const unit = match[2];
+        if (unit) {
+          return `${num}${unit}`;
+        }
+        return num;
+      }
+      return parseFloat(token.value);
+    }
+    if (token.type === "BOOLEAN") {
+      this.advance();
+      return token.value === "true";
+    }
+    if (token.type === "NULL") {
+      this.advance();
+      return null;
+    }
+    if (token.type === "EXPRESSION") {
+      this.advance();
+      const exprId = `expr_${this.compiledExpressions.size}`;
+      this.compiledExpressions.set(exprId, token.value);
+      return { __expr: exprId, __raw: token.value };
+    }
+    if (token.type === "TEMPLATE_STRING") {
+      this.advance();
+      return { type: "templateLiteral", value: token.value };
+    }
+    if (token.type === "LBRACKET") {
+      return this.parseArray();
+    }
+    if (token.type === "LBRACE") {
+      return this.parseBlockContent();
+    }
+    if (token.type === "HASH") {
+      this.advance();
+      const nextToken = this.current();
+      if (nextToken.type === "IDENTIFIER" || nextToken.type === "NUMBER") {
+        const hexValue = this.advance().value;
+        return `#${hexValue}`;
+      }
+      return `#`;
+    }
+    if (token.type === "THIS") {
+      this.advance();
+      let ref = "this";
+      while (this.check("DOT")) {
+        this.advance();
+        const part = this.expect("IDENTIFIER", "Expected property name").value;
+        ref += "." + part;
+      }
+      return { __ref: ref };
+    }
+    if (token.type === "LPAREN") {
+      let isArrow = false;
+      let i = 1;
+      let parenDepth = 1;
+      while (this.peek(i).type !== "EOF") {
+        const t = this.peek(i);
+        if (t.type === "LPAREN") parenDepth++;
+        if (t.type === "RPAREN") {
+          parenDepth--;
+          if (parenDepth === 0) {
+            const next = this.peek(i + 1);
+            if (next.type === "ARROW") isArrow = true;
+            if (next.type === "COLON") {
+              let j = i + 2;
+              while (this.peek(j).type === "IDENTIFIER" || this.peek(j).type === "LBRACKET" || this.peek(j).type === "RBRACKET")
+                j++;
+              if (this.peek(j).type === "ARROW") isArrow = true;
+            }
+            break;
+          }
+        }
+        i++;
+      }
+      if (isArrow) {
+        return this.parseArrowFunction();
+      }
+      return this.parseParenExpression();
+    }
+    if (token.type === "MATCH") {
+      return this.parseMatchExpression();
+    }
+    const isIdentifierLike = token.type === "IDENTIFIER" || token.type === "STATE" || token.type === "INITIAL" || token.type === "STATE_MACHINE" || token.type === "TRANSITION" || token.type === "ON_ENTRY" || token.type === "ON_EXIT";
+    if (isIdentifierLike) {
+      if (this.peek(1).type === "ARROW") {
+        return this.parseArrowFunction();
+      }
+      this.advance();
+      let ref = token.value;
+      while (this.check("DOT") || this.check("OPTIONAL_DOT") || this.check("LBRACKET")) {
+        if (this.check("OPTIONAL_DOT")) {
+          this.advance();
+          const nextToken = this.current();
+          const isPropertyName = nextToken.type === "IDENTIFIER" || nextToken.type === "STATE" || nextToken.type === "INITIAL" || nextToken.type === "STATE_MACHINE" || nextToken.type === "TRANSITION" || nextToken.type === "ON_ENTRY" || nextToken.type === "ON_EXIT";
+          if (isPropertyName) {
+            ref += "?." + this.advance().value;
+          } else {
+            this.error("Expected property name after optional chaining (?.)", "HSP002");
+          }
+        } else if (this.check("LBRACKET")) {
+          this.advance();
+          const indexExpr = this.parseValue();
+          this.expect("RBRACKET", "Expected ]");
+          const base = ref;
+          return { type: "computedMember", object: { __ref: base }, property: indexExpr };
+        } else {
+          this.advance();
+          const nextToken = this.current();
+          const isPropertyName = nextToken.type === "IDENTIFIER" || nextToken.type === "STATE" || nextToken.type === "INITIAL" || nextToken.type === "STATE_MACHINE" || nextToken.type === "TRANSITION" || nextToken.type === "ON_ENTRY" || nextToken.type === "ON_EXIT";
+          if (isPropertyName) {
+            ref += "." + this.advance().value;
+          } else {
+            this.error("Expected property name after dot (.)", "HSP002");
+          }
+        }
+      }
+      if (this.check("LPAREN")) {
+        const args = this.parseParenExpression();
+        return { type: "call", callee: ref, args };
+      }
+      return { __ref: ref };
+    }
+    if (this.check("AT")) {
+      const dir = this.parseDirective();
+      return dir;
+    }
+    this.error(
+      `Unexpected token in expression: ${token.type} "${token.value}". Expected value, identifier, or expression`,
+      "HSP300"
+    );
+    const err = new Error("ParseError");
+    err.message = "ParseError";
+    throw err;
+  }
+  parseParenExpression() {
+    this.expect("LPAREN", "Expected (");
+    const items = [];
+    while (!this.check("RPAREN") && !this.check("EOF")) {
+      items.push(this.parseValue());
+      if (this.check("COMMA")) this.advance();
+    }
+    this.expect("RPAREN", "Expected )");
+    return items.length === 1 ? items[0] : items;
+  }
+  parseArrowFunction() {
+    const params = [];
+    if (this.check("LPAREN")) {
+      this.advance();
+      while (!this.check("RPAREN") && !this.check("EOF")) {
+        if (this.check("SPREAD")) {
+          this.advance();
+          const name2 = this.expect("IDENTIFIER", "Expected parameter name after ...").value;
+          let type2 = null;
+          if (this.check("COLON")) {
+            this.advance();
+            type2 = this.expect("IDENTIFIER", "Expected type").value;
+          }
+          params.push({ name: name2, type: type2, rest: true });
+          if (this.check("COMMA")) this.advance();
+          break;
+        }
+        const name = this.expect("IDENTIFIER", "Expected parameter name").value;
+        let type = null;
+        if (this.check("COLON")) {
+          this.advance();
+          type = this.expect("IDENTIFIER", "Expected type").value;
+        }
+        params.push({ name, type });
+        if (this.check("COMMA")) this.advance();
+      }
+      this.expect("RPAREN", "Expected )");
+    } else {
+      if (this.check("SPREAD")) {
+        this.advance();
+        const name = this.expect("IDENTIFIER", "Expected parameter name after ...").value;
+        params.push({ name, type: null, rest: true });
+      } else {
+        const name = this.expect("IDENTIFIER", "Expected parameter name").value;
+        params.push({ name, type: null });
+      }
+    }
+    let returnType = null;
+    if (this.check("COLON")) {
+      this.advance();
+      returnType = this.expect("IDENTIFIER", "Expected return type").value;
+    }
+    this.expect("ARROW", "Expected =>");
+    let body;
+    if (this.check("LBRACE")) {
+      body = this.parseCodeBlock();
+    } else {
+      body = this.parseInlineExpression();
+    }
+    return { type: "arrow_function", params, returnType, body };
+  }
+  parseArray() {
+    const arr = [];
+    this.expect("LBRACKET", "Expected [");
+    this.skipNewlines();
+    while (!this.check("RBRACKET") && !this.check("EOF")) {
+      const beforePos = this.pos;
+      this.skipNewlines();
+      if (this.check("RBRACKET") || this.check("EOF")) break;
+      if (this.check("SPREAD")) {
+        this.advance();
+        const spreadArg = this.parseValue();
+        if (spreadArg === null) {
+          this.error(
+            "Expected expression after spread operator (...) in array. Example: [...items]",
+            "HSP300"
+          );
+        } else {
+          arr.push({ type: "spread", argument: spreadArg });
+        }
+      } else {
+        const value = this.parseValue();
+        if (value !== null) {
+          arr.push(value);
+        } else if (this.pos === beforePos) {
+          this.advance();
+        }
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACKET", "Expected ]");
+    return arr;
+  }
+  parseObject() {
+    const obj = {};
+    this.expect("LBRACE", "Expected {");
+    this.skipNewlines();
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE") || this.check("EOF")) break;
+      if (this.check("SPREAD")) {
+        this.advance();
+        const spreadArg = this.parseValue();
+        if (spreadArg === null) {
+          this.error(
+            "Expected expression after spread operator (...) in object. Example: {...template}",
+            "HSP300"
+          );
+        } else {
+          const spreadKey = `__spread_${Object.keys(obj).length}`;
+          obj[spreadKey] = { type: "spread", argument: spreadArg };
+        }
+      } else if (this.check("IDENTIFIER")) {
+        const key = this.advance().value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          obj[key] = this.parseValue();
+        } else {
+          obj[key] = true;
+        }
+      } else {
+        this.advance();
+        continue;
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected }");
+    return obj;
+  }
+  /**
+   * Parse a match expression: match subject { pattern => body, ... }
+   * Supports:
+   * - Literal patterns: "idle", 42, true
+   * - Wildcard pattern: _
+   * - Binding patterns: x (captures value)
+   * - Guard clauses: pattern if condition => body
+   */
+  parseMatchExpression() {
+    const startToken = this.current();
+    this.expect("MATCH", "Expected match keyword");
+    const subject = this.parseValue();
+    if (subject === null) {
+      this.error("Expected expression after match keyword", "HSP300");
+      return null;
+    }
+    this.expect("LBRACE", "Expected { after match subject");
+    this.skipNewlines();
+    const cases = [];
+    let hasWildcard = false;
+    while (!this.check("RBRACE") && !this.check("EOF")) {
+      this.skipNewlines();
+      if (this.check("RBRACE")) break;
+      const caseNode = this.parseMatchCase();
+      if (caseNode) {
+        cases.push(caseNode);
+        if (caseNode.pattern && caseNode.pattern.type === "wildcard-pattern") {
+          hasWildcard = true;
+        }
+      }
+      if (this.check("COMMA")) this.advance();
+      this.skipNewlines();
+    }
+    this.expect("RBRACE", "Expected } to close match expression");
+    return {
+      type: "match",
+      subject,
+      cases,
+      hasWildcard,
+      sourceLocation: {
+        line: startToken.line,
+        column: startToken.column
+      }
+    };
+  }
+  /**
+   * Parse a single match case: pattern [if guard] => body
+   */
+  parseMatchCase() {
+    const pattern = this.parseMatchPattern();
+    if (!pattern) {
+      return null;
+    }
+    let guard;
+    if (this.check("IDENTIFIER") && this.current().value === "if") {
+      this.advance();
+      let guardExpr = "";
+      while (!this.check("ARROW") && !this.check("EOF") && !this.check("RBRACE")) {
+        guardExpr += this.current().value + " ";
+        this.advance();
+      }
+      guard = guardExpr.trim();
+    }
+    this.expect("ARROW", "Expected => after match pattern");
+    let body;
+    if (this.check("LBRACE")) {
+      body = this.parseBlockContent();
+    } else {
+      body = this.parseValue();
+    }
+    return {
+      type: "match-case",
+      pattern,
+      body,
+      guard
+    };
+  }
+  /**
+   * Parse a match pattern:
+   * - Literal: "string", 42, true
+   * - Wildcard: _
+   * - Binding: identifier
+   */
+  parseMatchPattern() {
+    const token = this.current();
+    if (token.type === "UNDERSCORE" || token.type === "IDENTIFIER" && token.value === "_") {
+      this.advance();
+      return {
+        type: "wildcard-pattern",
+        symbol: "_"
+      };
+    }
+    if (token.type === "STRING") {
+      this.advance();
+      return {
+        type: "literal-pattern",
+        value: token.value
+      };
+    }
+    if (token.type === "NUMBER") {
+      this.advance();
+      return {
+        type: "literal-pattern",
+        value: parseFloat(token.value)
+      };
+    }
+    if (token.type === "BOOLEAN") {
+      this.advance();
+      return {
+        type: "literal-pattern",
+        value: token.value === "true"
+      };
+    }
+    if (token.type === "IDENTIFIER") {
+      this.advance();
+      return {
+        type: "binding-pattern",
+        name: token.value
+      };
+    }
+    if (token.type === "NULL") {
+      this.advance();
+      return {
+        type: "literal-pattern",
+        value: null
+      };
+    }
+    this.error(`Expected match pattern (literal, identifier, or _), got ${token.type}`, "HSP300");
+    return null;
+  }
+  current() {
+    return this.tokens[this.pos] || { type: "EOF", value: "", line: 0, column: 0 };
+  }
+  peek(offset = 0) {
+    return this.tokens[this.pos + offset] || { type: "EOF", value: "", line: 0, column: 0 };
+  }
+  check(type) {
+    return this.current().type === type;
+  }
+  advance() {
+    const token = this.current();
+    if (this.pos < this.tokens.length) {
+      this.pos++;
+    }
+    return token;
+  }
+  previous() {
+    return this.tokens[this.pos - 1] || this.current();
+  }
+  match(types) {
+    for (const type of types) {
+      if (this.check(type)) {
+        return this.advance();
+      }
+    }
+    return null;
+  }
+  expect(type, message) {
+    if (!this.check(type)) {
+      const current = this.current();
+      const fullMessage = `${message}. Got ${current.type} "${current.value}"`;
+      let errorCode = "HSP001";
+      let suggestion;
+      switch (type) {
+        case "RBRACE":
+          errorCode = "HSP004";
+          suggestion = "Check for matching opening brace { and ensure all blocks are properly closed";
+          break;
+        case "RBRACKET":
+          errorCode = "HSP005";
+          suggestion = "Check for matching opening bracket [ and ensure all arrays are properly closed";
+          break;
+        case "RPAREN":
+          errorCode = "HSP006";
+          suggestion = "Check for matching opening parenthesis ( and ensure all expressions are properly closed";
+          break;
+        case "COLON":
+          errorCode = "HSP009";
+          suggestion = "Properties use colon syntax: propertyName: value";
+          break;
+        case "IDENTIFIER":
+          errorCode = "HSP002";
+          if (current.type === "IDENTIFIER") {
+            const similar = findSimilarKeyword(current.value);
+            if (similar) {
+              suggestion = `Did you mean '${similar}'?`;
+            }
+          }
+          break;
+        case "LBRACE":
+          errorCode = "HSP100";
+          suggestion = "Expected opening brace { to start block";
+          break;
+        default:
+          errorCode = "HSP001";
+      }
+      if (suggestion) {
+        this.errorWithSuggestion(fullMessage, suggestion, errorCode);
+      } else {
+        this.error(fullMessage, errorCode);
+      }
+      if (type === "RBRACE" || type === "LBRACE" || type === "IDENTIFIER") {
+        this.synchronize();
+      }
+      return current;
+    }
+    return this.advance();
+  }
+  skipNewlines() {
+    while (this.check("NEWLINE") || this.check("INDENT") || this.check("DEDENT")) {
+      this.advance();
+    }
+  }
+  /** Skip a balanced parenthesised list ( ... ) including nested parens */
+  skipParens() {
+    if (!this.check("LPAREN")) return;
+    this.advance();
+    let depth = 1;
+    while (depth > 0 && !this.check("EOF")) {
+      if (this.check("LPAREN")) depth++;
+      if (this.check("RPAREN")) depth--;
+      this.advance();
+    }
+  }
+  skipBraces() {
+    if (!this.check("LBRACE")) return;
+    this.advance();
+    let depth = 1;
+    while (depth > 0 && !this.check("EOF")) {
+      if (this.check("LBRACE")) depth++;
+      if (this.check("RBRACE")) depth--;
+      this.advance();
+    }
+  }
+  error(message, code = "HSP001") {
+    const token = this.current();
+    const line = token.line;
+    const column = token.column;
+    let suggestion;
+    if (token.type === "IDENTIFIER") {
+      const similar = findSimilarKeyword(token.value);
+      if (similar) {
+        suggestion = `Did you mean '${similar}'?`;
+      }
+    }
+    this.errors.push(
+      createRichError(code, message, line, column, {
+        source: this.source,
+        suggestion,
+        severity: "error"
+      })
+    );
+  }
+  errorWithSuggestion(message, suggestion, code = "HSP001") {
+    const token = this.current();
+    this.errors.push(
+      createRichError(code, message, token.line, token.column, {
+        source: this.source,
+        suggestion,
+        severity: "error"
+      })
+    );
+  }
+  traitError(traitName) {
+    const token = this.current();
+    this.errors.push(createTraitError(traitName, token.line, token.column, this.source));
+  }
+  warn(message, code = "HSP001") {
+    const token = this.current();
+    this.warnings.push(
+      createRichError(code, message, token.line, token.column, {
+        source: this.source,
+        severity: "warning"
+      })
+    );
+  }
+  /**
+   * Detect common mistakes and provide context-aware error messages
+   */
+  detectCommonMistake() {
+    const current = this.current();
+    const prev = this.pos > 0 ? this.tokens[this.pos - 1] : null;
+    const next = this.pos + 1 < this.tokens.length ? this.tokens[this.pos + 1] : null;
+    if (current.type === "EQUALS" && prev?.type === "IDENTIFIER") {
+      return {
+        message: `Unexpected '=' after property name '${prev.value}'`,
+        suggestion: "Use ':' instead of '=' for property assignment. Example: propertyName: value",
+        code: "HSP009"
+      };
+    }
+    if (current.value === ";") {
+      return {
+        message: "Unexpected semicolon",
+        suggestion: "HoloScript does not require semicolons. Remove the semicolon to continue.",
+        code: "HSP001"
+      };
+    }
+    if (current.type === "IDENTIFIER" && VR_TRAITS.includes(current.value)) {
+      if (prev?.type !== "AT") {
+        return {
+          message: `'${current.value}' is a trait and requires '@' prefix`,
+          suggestion: `Use '@${current.value}' to apply this trait`,
+          code: "HSP200"
+        };
+      }
+    }
+    if (current.type === "STRING" && next?.type === "COLON") {
+      return {
+        message: "Property names should not be quoted in HoloScript",
+        suggestion: `Remove quotes: use ${current.value.replace(/['"]/g, "")}: instead of "${current.value}":`,
+        code: "HSP101"
+      };
+    }
+    if (current.value === "function" && prev?.type === "COLON") {
+      return {
+        message: "Unexpected 'function' keyword",
+        suggestion: "Use arrow function syntax: handler: (args) => { ... }",
+        code: "HSP300"
+      };
+    }
+    if (current.type === "SPREAD" && next && (next.type === "RBRACE" || next.type === "RBRACKET" || next.type === "COMMA" || next.type === "NEWLINE")) {
+      return {
+        message: "Spread operator (...) requires a target expression",
+        suggestion: "Provide an expression to spread: ...targetObject or ...targetArray",
+        code: "HSP002"
+      };
+    }
+    return null;
+  }
+  /**
+   * Enhanced error reporting with common mistake detection
+   */
+  errorWithContext(message, code = "HSP001") {
+    const commonMistake = this.detectCommonMistake();
+    if (commonMistake) {
+      this.errorWithSuggestion(commonMistake.message, commonMistake.suggestion, commonMistake.code);
+      return;
+    }
+    this.error(message, code);
+  }
+  /**
+   * Synchronize parser state after an error
+   * Skips tokens until a potential recovery point (newline followed by keyword/directive)
+   */
+  synchronize() {
+    this.advance();
+    while (!this.check("EOF")) {
+      if (this.check("RBRACE")) {
+        return;
+      }
+      if (this.check("IDENTIFIER") && ["orb", "template", "logic", "object", "composition", "scene", "group"].includes(
+        this.current().value
+      )) {
+        return;
+      }
+      if (this.check("AT")) {
+        return;
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Mini-sync for property lists: skips until next line or comma
+   */
+  synchronizeProperty() {
+    this.advance();
+    while (!this.check("EOF")) {
+      if (this.check("RBRACE") || this.check("LBRACE")) {
+        return;
+      }
+      if (this.check("IDENTIFIER") || this.check("STRING") || this.check("SPREAD") || this.check("AT")) {
+        return;
+      }
+      if (this.check("NEWLINE")) {
+        this.advance();
+        this.skipNewlines();
+        if (this.check("IDENTIFIER") || this.check("STRING") || this.check("SPREAD") || this.check("AT")) {
+          return;
+        }
+      }
+      if (this.check("COMMA")) {
+        this.advance();
+        return;
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Synchronize for array context: skip to next valid array element or closing bracket
+   */
+  synchronizeArray() {
+    while (!this.check("EOF")) {
+      if (this.check("RBRACKET")) {
+        return;
+      }
+      if (this.check("COMMA")) {
+        this.advance();
+        this.skipNewlines();
+        return;
+      }
+      if (this.check("NEWLINE")) {
+        this.advance();
+        this.skipNewlines();
+        if (this.check("RBRACKET") || this.isLikelyValue(this.current()) || this.check("SPREAD")) {
+          return;
+        }
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Synchronize for expression context: skip to end of expression
+   */
+  synchronizeExpression() {
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    while (!this.check("EOF")) {
+      const token = this.current();
+      if (token.type === "LPAREN") parenDepth++;
+      else if (token.type === "RPAREN") {
+        if (parenDepth === 0) return;
+        parenDepth--;
+      } else if (token.type === "LBRACE") braceDepth++;
+      else if (token.type === "RBRACE") {
+        if (braceDepth === 0) return;
+        braceDepth--;
+      } else if (token.type === "LBRACKET") bracketDepth++;
+      else if (token.type === "RBRACKET") {
+        if (bracketDepth === 0) return;
+        bracketDepth--;
+      }
+      if (parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) {
+        if (this.check("NEWLINE") || this.check("COMMA")) {
+          return;
+        }
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Attempt to recover from missing colon by looking ahead
+   * Returns true if recovery was successful
+   */
+  tryRecoverMissingColon() {
+    if (this.check("IDENTIFIER")) {
+      const nextPos = this.pos + 1;
+      if (nextPos < this.tokens.length) {
+        const nextToken = this.tokens[nextPos];
+        if (this.isLikelyValue(nextToken) || nextToken.type === "IDENTIFIER") {
+          this.warn(
+            `Missing colon after property "${this.current().value}". Consider adding ':' between property name and value`,
+            "HSP009"
+          );
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Helper to check if current token is a natural boundary after a value
+   */
+  isValueBoundary() {
+    return this.check("NEWLINE") || this.check("RBRACE") || this.check("COMMA") || this.check("IDENTIFIER") || this.check("SPREAD") || this.check("AT") || this.check("EOF");
+  }
+  /**
+   * Helper to check if a token is likely the start of a value
+   */
+  isLikelyValue(token) {
+    return token.type === "STRING" || token.type === "NUMBER" || token.type === "LBRACKET" || token.type === "LBRACE" || token.type === "BOOLEAN" || token.type === "NULL" || token.type === "TEMPLATE_STRING";
+  }
+  /**
+   * Parse a block of raw code (balanced braces)
+   */
+  parseRawBlock() {
+    const startToken = this.expect("LBRACE", "Expected {");
+    const startOffset = startToken.offset + 1;
+    let braceDepth = 1;
+    let endOffset = startOffset;
+    while (braceDepth > 0 && this.pos < this.tokens.length) {
+      const token = this.current();
+      if (token.type === "EOF") break;
+      if (token.type === "LBRACE") {
+        braceDepth++;
+      } else if (token.type === "RBRACE") {
+        braceDepth--;
+        if (braceDepth === 0) {
+          endOffset = token.offset;
+          break;
+        }
+      }
+      this.advance();
+    }
+    this.expect("RBRACE", "Expected }");
+    return this.source.substring(startOffset, endOffset).trim();
+  }
+};
+function createParser(options) {
+  return new HoloScriptPlusParser(options);
+}
+function parse(source, options) {
+  const parser = createParser(options);
+  return parser.parse(source);
+}
+
+export { ChunkBasedIncrementalParser, HSPLUS_ERROR_CODES, HoloScriptPlusParser, ParseCache, createKeywordError, createParser, createRichError, createTraitError, findSimilarKeyword, findSimilarTrait, formatRichError, formatRichErrors, getErrorCodeDocumentation, getSourceContext, globalParseCache, parse, parseIncrementalChunks };
+//# sourceMappingURL=chunk-YIMN575O.js.map
+//# sourceMappingURL=chunk-YIMN575O.js.map