@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-V3NN3HPP.js

@@ -1,4462 +0,0 @@
-import { ErrorRecovery, generateQuickFixes, enrichErrorWithSuggestions, LIFECYCLE_HOOKS, STRUCTURAL_DIRECTIVES } from './chunk-MPXBVFHQ.js';
-import { VR_TRAITS } from './chunk-NDQNIJEH.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/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();
-    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 cached nodes for unchanged chunks
-   */
-  parseIncremental(source, cache = globalParseCache) {
-    this.source = source;
-    this.errors = [];
-    this.warnings = [];
-    this.imports = [];
-    this.hasState = false;
-    this.hasVRTraits = false;
-    this.hasControlFlow = false;
-    this.compiledExpressions = /* @__PURE__ */ new Map();
-    const chunks = ChunkDetector.detect(source);
-    const topLevelNodes = [];
-    const globalDirectives = [];
-    for (const chunk of chunks) {
-      const hash = ParseCache.hash(chunk.content);
-      const cachedNode = cache.get(chunk.id, hash);
-      if (cachedNode) {
-        topLevelNodes.push(cachedNode);
-      } else {
-        const chunkResult = this.parse(chunk.content);
-        const chunkAst = chunkResult.ast;
-        const chunkFeatures = chunkResult.features;
-        if (chunkAst?.root) {
-          const node = chunkAst.root;
-          this.offsetNodeLoc(node, chunk.startLine - 1);
-          topLevelNodes.push(node);
-          cache.set(chunk.id, hash, node);
-          this.hasState = this.hasState || !!chunkFeatures?.state;
-          this.hasVRTraits = this.hasVRTraits || !!chunkFeatures?.vrTraits;
-          this.hasControlFlow = this.hasControlFlow || !!chunkFeatures?.loops || !!chunkFeatures?.conditionals;
-          this.imports.push(...chunkAst.imports);
-        }
-        this.errors.push(...chunkResult.errors);
-        this.warnings.push(...chunkResult.warnings || []);
-      }
-    }
-    const root = {
-      type: "fragment",
-      id: "root",
-      properties: {},
-      directives: globalDirectives,
-      children: topLevelNodes,
-      traits: /* @__PURE__ */ new Map(),
-      loc: {
-        start: { line: 1, column: 1 },
-        end: { line: chunks.length > 0 ? chunks[chunks.length - 1].endLine : 1, column: 1 }
-      },
-      body: topLevelNodes
-    };
-    const result = this.buildResult(root);
-    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 ast = {
-      type: "Program",
-      id: "root",
-      properties: isFragment ? root.properties || {} : {},
-      directives,
-      children: isFragment ? root.children || [] : [root],
-      traits: isFragment ? root.traits || /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(),
-      loc: root.loc,
-      body: isFragment ? root.children || [] : [root],
-      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, 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, 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") {
-      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();
-      return {
-        type: "composition",
-        name: id2,
-        id: id2,
-        properties: compBody.properties || {},
-        directives: [],
-        children: compBody.children,
-        traits: /* @__PURE__ */ new Map(),
-        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 === "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",
-                "module",
-                "struct",
-                "orb",
-                "on_error",
-                "assert",
-                "transition",
-                "on_entry",
-                "on_exit"
-              ];
-              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 { 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 { type: "trait", 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",
-      "module",
-      "struct",
-      "orb",
-      "on_error",
-      "assert",
-      "topic",
-      "channel",
-      "config",
-      "zone",
-      "audio",
-      "light",
-      "npc",
-      "camera",
-      "timeline"
-    ];
-    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 (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")) {
-          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") {
-          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: [],
-      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 === "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 { ChunkDetector, HSPLUS_ERROR_CODES, HoloScriptPlusParser, ParseCache, createKeywordError, createParser, createRichError, createTraitError, findSimilarKeyword, findSimilarTrait, formatRichError, formatRichErrors, getErrorCodeDocumentation, getSourceContext, globalParseCache, parse };
-//# sourceMappingURL=chunk-V3NN3HPP.js.map
-//# sourceMappingURL=chunk-V3NN3HPP.js.map