@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-JIYN45TV.cjs

@@ -0,0 +1,2525 @@
+'use strict';
+
+var chunkILRBGFVD_cjs = require('./chunk-ILRBGFVD.cjs');
+
+// src/HoloScriptPersistenceParser.ts
+var HoloScriptPersistenceParser = class {
+  constructor(context) {
+    this.ctx = context;
+  }
+  /**
+   * Parse memory primitive block
+   * memory <Name> { semantic: SemanticMemory { ... }, episodic: EpisodicMemory { ... }, procedural: ProceduralMemory { ... } }
+   */
+  parseMemory() {
+    const startToken = this.ctx.check("keyword", "memory");
+    if (!startToken) {
+      return null;
+    }
+    this.ctx.advance();
+    const name = this.ctx.expectIdentifier() || "UnnamedMemory";
+    const node = {
+      type: "memory",
+      name,
+      position: [0, 0, 0]
+    };
+    if (this.ctx.check("punctuation", "{")) {
+      this.ctx.advance();
+      while (!this.ctx.check("punctuation", "}") && this.ctx.position < this.ctx.tokens.length) {
+        this.ctx.skipNewlines();
+        if (this.ctx.check("punctuation", "}")) break;
+        const keyToken = this.ctx.currentToken();
+        if (!keyToken || keyToken.type !== "identifier" && keyToken.type !== "keyword") {
+          this.ctx.advance();
+          continue;
+        }
+        const key = keyToken.value;
+        this.ctx.advance();
+        if (this.ctx.check("punctuation", ":")) {
+          this.ctx.advance();
+        }
+        const typeToken = this.ctx.currentToken();
+        if (typeToken && (typeToken.type === "identifier" || typeToken.type === "keyword")) {
+          this.ctx.advance();
+          if (this.ctx.check("punctuation", "{")) {
+            const properties = this.ctx.parseObject();
+            if (key === "semantic" && typeToken.value === "SemanticMemory") {
+              node.semantic = {
+                type: "semantic-memory",
+                properties,
+                position: [0, 0, 0]
+              };
+            } else if (key === "episodic" && typeToken.value === "EpisodicMemory") {
+              node.episodic = {
+                type: "episodic-memory",
+                properties,
+                position: [0, 0, 0]
+              };
+            } else if (key === "procedural" && typeToken.value === "ProceduralMemory") {
+              node.procedural = {
+                type: "procedural-memory",
+                properties,
+                position: [0, 0, 0]
+              };
+            }
+          }
+        }
+        if (this.ctx.check("punctuation", ",")) {
+          this.ctx.advance();
+        }
+      }
+      this.ctx.expect("punctuation", "}");
+    }
+    return node;
+  }
+};
+
+// src/HoloScriptCodeParser.ts
+var ObjectPool = class {
+  constructor(createFn, resetFn, maxSize = 100) {
+    this.pool = [];
+    this.createFn = createFn;
+    this.resetFn = resetFn;
+    this.maxSize = maxSize;
+  }
+  /** Get an object from pool or create new one */
+  acquire() {
+    if (this.pool.length > 0) {
+      return this.pool.pop();
+    }
+    return this.createFn();
+  }
+  /** Return object to pool for reuse */
+  release(obj) {
+    if (this.pool.length < this.maxSize) {
+      this.resetFn(obj);
+      this.pool.push(obj);
+    }
+  }
+  /** Clear the pool */
+  clear() {
+    this.pool.length = 0;
+  }
+  /** Get pool statistics */
+  get stats() {
+    return { pooled: this.pool.length, maxSize: this.maxSize };
+  }
+};
+var tokenPool = new ObjectPool(
+  () => ({ type: "", value: "", line: 0, column: 0 }),
+  (t) => {
+    t.type = "";
+    t.value = "";
+    t.line = 0;
+    t.column = 0;
+  }
+);
+var arrayPool = new ObjectPool(
+  () => [],
+  (arr) => {
+    arr.length = 0;
+  },
+  50
+);
+var ParserPools = {
+  token: tokenPool,
+  array: arrayPool,
+  clearAll: () => {
+    tokenPool.clear();
+    arrayPool.clear();
+  },
+  getStats: () => ({
+    token: tokenPool.stats,
+    array: arrayPool.stats
+  })
+};
+var CODE_SECURITY_CONFIG = {
+  maxCodeLength: 5e4,
+  maxBlocks: 100,
+  suspiciousKeywords: [
+    "process",
+    "require",
+    "eval",
+    "constructor",
+    "prototype",
+    "__proto__",
+    "fs",
+    "child_process",
+    "exec",
+    "spawn"
+  ]
+};
+function stripCommentsAndStrings(code) {
+  let result = "";
+  let i = 0;
+  while (i < code.length) {
+    if (code[i] === "/" && code[i + 1] === "/") {
+      while (i < code.length && code[i] !== "\n") i++;
+      continue;
+    }
+    if (code[i] === "/" && code[i + 1] === "*") {
+      i += 2;
+      while (i < code.length - 1 && !(code[i] === "*" && code[i + 1] === "/")) i++;
+      i += 2;
+      continue;
+    }
+    if (code[i] === '"') {
+      i++;
+      while (i < code.length && code[i] !== '"') {
+        if (code[i] === "\\" && i + 1 < code.length) i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    if (code[i] === "'") {
+      i++;
+      while (i < code.length && code[i] !== "'") {
+        if (code[i] === "\\" && i + 1 < code.length) i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    result += code[i];
+    i++;
+  }
+  return result;
+}
+var ERROR_CODES = {
+  HS001: "Expected keyword - a required keyword is missing",
+  HS002: "Expected identifier - a name is required here",
+  HS003: "Expected operator - an operator like = or : is required",
+  HS004: "Unexpected token - this token is not valid in this context",
+  HS005: "Unclosed block - missing closing brace }",
+  HS006: "Unclosed string - missing closing quote",
+  HS007: "Invalid number - numeric literal is malformed",
+  HS008: "Unknown keyword - this keyword is not recognized",
+  HS009: "Too many items - limit exceeded for performance",
+  HS010: "Security violation - blocked for security reasons"
+};
+var HoloScriptCodeParser = class {
+  constructor() {
+    this.errors = [];
+    this.warnings = [];
+    this.tokens = [];
+    this.position = 0;
+    /** Source code lines for error context */
+    this.sourceLines = [];
+    this.persistenceParser = new HoloScriptPersistenceParser(this);
+    this.keywordSet = /* @__PURE__ */ new Set([
+      "orb",
+      "function",
+      "connect",
+      "to",
+      "as",
+      "gate",
+      "stream",
+      "from",
+      "through",
+      "return",
+      "if",
+      "else",
+      "nexus",
+      "building",
+      "pillar",
+      "foundation",
+      "for",
+      "while",
+      "forEach",
+      "in",
+      "of",
+      "break",
+      "continue",
+      "import",
+      "export",
+      "module",
+      "use",
+      "type",
+      "interface",
+      "extends",
+      "implements",
+      "is",
+      "async",
+      "await",
+      "spawn",
+      "parallel",
+      "class",
+      "new",
+      "this",
+      "super",
+      "static",
+      "private",
+      "public",
+      "try",
+      "catch",
+      "finally",
+      "throw",
+      "const",
+      "let",
+      "var",
+      "animate",
+      "modify",
+      "pulse",
+      "move",
+      "show",
+      "hide",
+      "scale",
+      "focus",
+      "environment",
+      "composition",
+      "template",
+      "settings",
+      "chat",
+      "migrate",
+      // Shape keywords for 3D objects
+      "cube",
+      "sphere",
+      "plane",
+      "cylinder",
+      "cone",
+      "torus",
+      "pyramid",
+      "box",
+      "mesh",
+      "model",
+      "object",
+      "light",
+      "camera",
+      // System and component keywords (Phase 0: Hololand Bootstrap)
+      "system",
+      "component",
+      "action",
+      "props",
+      // Additional scene keywords
+      "npc",
+      "player",
+      "entity",
+      "trigger",
+      "zone",
+      "portal",
+      "spatial_group",
+      "interactive",
+      "traits",
+      "on_interact",
+      "on_collision",
+      "on_enter",
+      "on_exit",
+      "using",
+      "memory",
+      "semantic",
+      "episodic",
+      "procedural"
+    ]);
+  }
+  /**
+   * Create a rich error with context and suggestions
+   */
+  createError(code, message, token, suggestion) {
+    const line = token?.line || 0;
+    const column = token?.column || 0;
+    let context = "";
+    if (this.sourceLines.length > 0 && line > 0) {
+      const lines = [];
+      if (line > 1) lines.push(`${line - 1} | ${this.sourceLines[line - 2] || ""}`);
+      lines.push(`${line} | ${this.sourceLines[line - 1] || ""}`);
+      lines.push(`    ${" ".repeat(column)}^`);
+      if (line < this.sourceLines.length)
+        lines.push(`${line + 1} | ${this.sourceLines[line] || ""}`);
+      context = lines.join("\n");
+    }
+    return {
+      line,
+      column,
+      message,
+      code,
+      context,
+      suggestion,
+      severity: "error"
+    };
+  }
+  /**
+   * Find similar keywords for "did you mean" suggestions
+   */
+  findSimilarKeyword(word) {
+    if (!word) return void 0;
+    const lower = word.toLowerCase();
+    let bestMatch;
+    let bestScore = 0;
+    for (const keyword of this.keywordSet) {
+      const score = this.similarity(lower, keyword);
+      if (score > bestScore && score > 0.6) {
+        bestScore = score;
+        bestMatch = keyword;
+      }
+    }
+    return bestMatch;
+  }
+  /**
+   * Simple Levenshtein-based similarity (0-1)
+   */
+  similarity(a, b) {
+    if (a === b) return 1;
+    if (a.length === 0 || b.length === 0) return 0;
+    const len = Math.max(a.length, b.length);
+    let matches = 0;
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+      if (a[i] === b[i]) matches++;
+    }
+    if (a.startsWith(b) || b.startsWith(a)) {
+      matches = Math.max(matches, Math.min(a.length, b.length));
+    }
+    return matches / len;
+  }
+  /**
+   * Add error and continue parsing (error recovery)
+   */
+  addError(error) {
+    if (!this.errors.some((e) => e.line === error.line && e.message === error.message)) {
+      this.errors.push(error);
+    }
+  }
+  /**
+   * Recover from error by skipping to next statement boundary
+   */
+  synchronize() {
+    while (this.position < this.tokens.length) {
+      const token = this.currentToken();
+      if (!token) break;
+      if (token.type === "newline") {
+        this.advance();
+        break;
+      }
+      if (token.type === "keyword" && [
+        "orb",
+        "function",
+        "gate",
+        "for",
+        "while",
+        "if",
+        "return",
+        "object",
+        "template",
+        "composition",
+        "spatial_group",
+        "logic"
+      ].includes(token.value)) {
+        break;
+      }
+      if (token.type === "punctuation" && ["}", ";"].includes(token.value)) {
+        this.advance();
+        break;
+      }
+      this.advance();
+    }
+  }
+  /**
+   * Parse HoloScript code string into AST
+   */
+  parse(code) {
+    this.errors = [];
+    this.warnings = [];
+    this.tokens = [];
+    this.position = 0;
+    this.sourceLines = code.split("\n");
+    if (code.length > CODE_SECURITY_CONFIG.maxCodeLength) {
+      return {
+        success: false,
+        ast: [],
+        errors: [
+          {
+            line: 0,
+            column: 0,
+            message: `Code exceeds max length (${CODE_SECURITY_CONFIG.maxCodeLength})`,
+            code: "HS009",
+            severity: "error"
+          }
+        ],
+        warnings: []
+      };
+    }
+    const strippedCode = stripCommentsAndStrings(code).toLowerCase();
+    for (const keyword of CODE_SECURITY_CONFIG.suspiciousKeywords) {
+      const regex = new RegExp(`\\b${keyword}\\b`, "i");
+      if (regex.test(strippedCode)) {
+        chunkILRBGFVD_cjs.logger.warn("Suspicious keyword detected", { keyword });
+        return {
+          success: false,
+          ast: [],
+          errors: [
+            {
+              line: 0,
+              column: 0,
+              message: `Suspicious keyword detected: ${keyword}`,
+              code: "HS010",
+              severity: "error"
+            }
+          ],
+          warnings: []
+        };
+      }
+    }
+    try {
+      this.tokens = this.tokenize(code);
+      const ast = this.parseProgram();
+      return {
+        success: this.errors.length === 0,
+        ast,
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    } catch (error) {
+      this.addError({
+        line: 0,
+        column: 0,
+        message: String(error),
+        code: "HS004",
+        severity: "error"
+      });
+      return {
+        success: false,
+        ast: [],
+        errors: this.errors,
+        warnings: this.warnings
+      };
+    }
+  }
+  /**
+   * Tokenize code into tokens
+   */
+  tokenize(code) {
+    const tokens = [];
+    let line = 1;
+    let column = 1;
+    let i = 0;
+    while (i < code.length) {
+      const char = code[i];
+      if (char === " " || char === "	" || char === "\r") {
+        i++;
+        column++;
+        continue;
+      }
+      if (char === "\n") {
+        tokens.push({ type: "newline", value: "\n", line, column });
+        line++;
+        column = 1;
+        i++;
+        continue;
+      }
+      if (char === "/" && code[i + 1] === "/") {
+        while (i < code.length && code[i] !== "\n") {
+          i++;
+        }
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        const quote = char;
+        let str = "";
+        const startCol = column;
+        i++;
+        column++;
+        while (i < code.length && code[i] !== quote) {
+          if (code[i] === "\\" && i + 1 < code.length) {
+            str += code[i + 1];
+            i += 2;
+            column += 2;
+          } else {
+            str += code[i];
+            i++;
+            column++;
+          }
+        }
+        i++;
+        column++;
+        tokens.push({ type: "string", value: str, line, column: startCol });
+        continue;
+      }
+      if (/[0-9]/.test(char) || char === "-" && /[0-9]/.test(code[i + 1])) {
+        let num = "";
+        const startCol = column;
+        while (i < code.length && /[0-9.\-]/.test(code[i])) {
+          num += code[i];
+          i++;
+          column++;
+        }
+        tokens.push({ type: "number", value: num, line, column: startCol });
+        continue;
+      }
+      if (/[a-zA-Z_]/.test(char)) {
+        let ident = "";
+        const startCol = column;
+        while (i < code.length && /[a-zA-Z0-9_]/.test(code[i])) {
+          ident += code[i];
+          i++;
+          column++;
+        }
+        const isKeyword = this.keywordSet.has(ident.toLowerCase());
+        tokens.push({
+          type: isKeyword ? "keyword" : "identifier",
+          value: ident,
+          line,
+          column: startCol
+        });
+        continue;
+      }
+      const multiCharOps = [
+        "===",
+        "!==",
+        "==",
+        "!=",
+        ">=",
+        "<=",
+        "&&",
+        "||",
+        "??",
+        "?.",
+        "++",
+        "--",
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+        "=>",
+        "->"
+      ];
+      let foundMultiOp = false;
+      for (const op of multiCharOps) {
+        if (code.substring(i, i + op.length) === op) {
+          tokens.push({ type: "operator", value: op, line, column });
+          i += op.length;
+          column += op.length;
+          foundMultiOp = true;
+          break;
+        }
+      }
+      if (foundMultiOp) continue;
+      const punctuation = [
+        "{",
+        "}",
+        "(",
+        ")",
+        "[",
+        "]",
+        ":",
+        ",",
+        ".",
+        ";",
+        "=",
+        "<",
+        ">",
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+        "!",
+        "&",
+        "|",
+        "?",
+        "#",
+        "@"
+      ];
+      if (punctuation.includes(char)) {
+        tokens.push({ type: "punctuation", value: char, line, column });
+        i++;
+        column++;
+        continue;
+      }
+      i++;
+      column++;
+    }
+    return tokens;
+  }
+  /**
+   * Parse program (list of declarations)
+   */
+  parseProgram() {
+    const nodes = [];
+    let blockCount = 0;
+    const maxErrors = 50;
+    while (this.position < this.tokens.length) {
+      if (this.errors.length >= maxErrors) {
+        this.addError({
+          line: 0,
+          column: 0,
+          message: `Too many errors (${maxErrors}+), stopping parse`,
+          code: "HS009",
+          severity: "error"
+        });
+        break;
+      }
+      while (this.currentToken()?.type === "newline") {
+        this.advance();
+      }
+      if (this.position >= this.tokens.length) break;
+      blockCount++;
+      if (blockCount > CODE_SECURITY_CONFIG.maxBlocks) {
+        this.addError({
+          line: 0,
+          column: 0,
+          message: "Too many blocks in program",
+          code: "HS009",
+          severity: "error"
+        });
+        break;
+      }
+      const errorCountBefore = this.errors.length;
+      const node = this.parseDeclaration();
+      if (node) {
+        nodes.push(node);
+      } else if (this.errors.length > errorCountBefore) {
+        this.synchronize();
+      }
+    }
+    return nodes;
+  }
+  /**
+   * Parse a single declaration
+   */
+  parseDeclaration() {
+    const token = this.currentToken();
+    if (!token) return null;
+    if (token.type === "keyword") {
+      switch (token.value.toLowerCase()) {
+        case "orb":
+        case "object":
+          return this.parseOrb();
+        case "function":
+          return this.parseFunction();
+        case "connect":
+          return this.parseConnection();
+        case "gate":
+        case "if":
+          return this.parseGate();
+        case "return":
+          return this.parseReturn();
+        case "stream":
+          return this.parseStream();
+        case "nexus":
+          return this.parseNexus();
+        case "building":
+        case "class":
+          return this.parseBuilding();
+        // Phase 2: Loop constructs
+        case "for":
+          return this.parseForLoop();
+        case "while":
+          return this.parseWhileLoop();
+        case "foreach":
+          return this.parseForEachLoop();
+        // Phase 2: Module system
+        case "import":
+          return this.parseImport();
+        case "export":
+          return this.parseExport();
+        // Phase 2: Variable declarations
+        // UI Extensions
+        case "ui2d":
+        case "card":
+        case "metric":
+        case "button":
+        case "row":
+        case "col":
+        case "text":
+          return this.parseUIElement();
+        case "const":
+        case "let":
+        case "var":
+          return this.parseVariableDeclaration();
+        // DSL-first commands (Phase 54)
+        case "animate":
+          return this.parseAnimate();
+        case "modify":
+          return this.parseModify();
+        case "scale":
+          return this.parseScale();
+        case "focus":
+          return this.parseFocus();
+        case "environment":
+          return this.parseEnvironment();
+        case "composition":
+          return this.parseComposition();
+        case "template":
+          return this.parseTemplate();
+        case "system":
+          return this.parseSystem();
+        case "component":
+          return this.parseComponent();
+        case "migrate":
+          return this.parseMigration();
+        case "settings":
+          return this.parseSettings();
+        case "chat":
+          return this.parseChat();
+        // Primitive 3D shapes (Phase 55)
+        case "cube":
+        case "sphere":
+        case "plane":
+        case "cylinder":
+        case "cone":
+        case "torus":
+        case "pyramid":
+        case "box":
+        case "mesh":
+        case "model":
+        case "light":
+        case "camera":
+          return this.parsePrimitive();
+        case "zone":
+          return this.parseZone();
+        case "memory":
+          return this.parseMemory();
+        default:
+          return this.parseExpressionStatement();
+      }
+    }
+    this.advance();
+    return null;
+  }
+  /**
+   * Parse for loop: for (init; condition; update) { body }
+   */
+  parseForLoop() {
+    this.expect("keyword", "for");
+    if (!this.check("punctuation", "(")) {
+      this.errors.push({ line: 0, column: 0, message: "Expected ( after for" });
+      return null;
+    }
+    this.advance();
+    let init = "", condition = "", update = "";
+    let depth = 0;
+    while (this.position < this.tokens.length) {
+      const t = this.currentToken();
+      if (!t) break;
+      if (t.value === ";" && depth === 0) {
+        this.advance();
+        break;
+      }
+      if (t.value === "(") depth++;
+      if (t.value === ")") depth--;
+      init += t.value + " ";
+      this.advance();
+    }
+    depth = 0;
+    while (this.position < this.tokens.length) {
+      const t = this.currentToken();
+      if (!t) break;
+      if (t.value === ";" && depth === 0) {
+        this.advance();
+        break;
+      }
+      if (t.value === "(") depth++;
+      if (t.value === ")") depth--;
+      condition += t.value + " ";
+      this.advance();
+    }
+    depth = 0;
+    while (this.position < this.tokens.length) {
+      const t = this.currentToken();
+      if (!t) break;
+      if (t.value === ")" && depth === 0) {
+        this.advance();
+        break;
+      }
+      if (t.value === "(") depth++;
+      if (t.value === ")") depth--;
+      update += t.value + " ";
+      this.advance();
+    }
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let braceDepth = 1;
+      while (braceDepth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) braceDepth++;
+        if (this.check("punctuation", "}")) braceDepth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "for-loop",
+      init: init.trim(),
+      condition: this.parseConditionExpression(condition.trim()),
+      update: update.trim(),
+      body,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse while loop: while (condition) { body }
+   */
+  parseWhileLoop() {
+    this.expect("keyword", "while");
+    let condition = "";
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        const t = this.currentToken();
+        if (!t) break;
+        if (t.value === "(") depth++;
+        if (t.value === ")") {
+          depth--;
+          if (depth === 0) {
+            this.advance();
+            break;
+          }
+        }
+        condition += t.value + " ";
+        this.advance();
+      }
+    }
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let braceDepth = 1;
+      while (braceDepth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) braceDepth++;
+        if (this.check("punctuation", "}")) braceDepth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "while-loop",
+      condition: this.parseConditionExpression(condition.trim()),
+      body: [],
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse forEach loop: forEach item in collection { body }
+   */
+  parseForEachLoop() {
+    this.expect("keyword", "forEach");
+    const variable = this.expectIdentifier();
+    this.expect("keyword", "in");
+    const collection = this.expectIdentifier();
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let braceDepth = 1;
+      while (braceDepth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) braceDepth++;
+        if (this.check("punctuation", "}")) braceDepth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "foreach-loop",
+      variable: variable || "item",
+      collection: collection || "items",
+      body: [],
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse import: import { x, y } from "module"
+   */
+  parseImport() {
+    this.expect("keyword", "import");
+    const imports = [];
+    let modulePath = "";
+    let defaultImport;
+    const current = this.currentToken();
+    if (current?.type === "string") {
+      modulePath = current.value;
+      this.advance();
+      return {
+        type: "import",
+        imports: [],
+        modulePath,
+        position: [0, 0, 0]
+      };
+    }
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        const name = this.expectIdentifier();
+        if (name) imports.push(name);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", "}");
+    } else {
+      defaultImport = this.expectIdentifier() || void 0;
+    }
+    if (this.check("keyword", "from")) {
+      this.advance();
+      const pathToken = this.currentToken();
+      if (pathToken?.type === "string") {
+        modulePath = pathToken.value;
+        this.advance();
+      }
+    }
+    return {
+      type: "import",
+      imports,
+      defaultImport,
+      modulePath,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse export: export { x, y } or export function/orb
+   */
+  parseExport() {
+    this.expect("keyword", "export");
+    const next = this.currentToken();
+    if (next?.type === "keyword") {
+      const declaration = this.parseDeclaration();
+      return {
+        type: "export",
+        declaration: declaration || void 0,
+        position: [0, 0, 0]
+      };
+    }
+    const exports$1 = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        const name = this.expectIdentifier();
+        if (name) exports$1.push(name);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "export",
+      exports: exports$1,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse variable declaration: const/let/var name = value
+   */
+  parseVariableDeclaration() {
+    const kindToken = this.currentToken()?.value.toLowerCase();
+    const kind = kindToken === "let" ? "let" : kindToken === "var" ? "var" : "const";
+    this.advance();
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    let dataType;
+    if (this.check("punctuation", ":")) {
+      this.advance();
+      dataType = this.expectIdentifier() || void 0;
+    }
+    const result = {
+      type: "variable-declaration",
+      kind,
+      name,
+      dataType,
+      value: void 0,
+      position: [0, 0, 0]
+    };
+    if (this.check("punctuation", "=")) {
+      this.advance();
+      const valueToken = this.currentToken();
+      if (valueToken?.type === "string") {
+        result.value = valueToken.value;
+        this.advance();
+      } else if (valueToken?.type === "number") {
+        result.value = parseFloat(valueToken.value);
+        this.advance();
+      } else if (this.check("punctuation", "[")) {
+        result.value = this.parseArray();
+      } else if (this.check("punctuation", "{")) {
+        result.value = this.parseObject();
+      } else if (valueToken?.type === "identifier") {
+        if (valueToken.value === "true") {
+          result.value = true;
+          this.advance();
+        } else if (valueToken.value === "false") {
+          result.value = false;
+          this.advance();
+        } else {
+          let expression = "";
+          while (this.position < this.tokens.length) {
+            const t = this.currentToken();
+            if (!t || t.type === "newline" || t.type === "punctuation" && t.value === ";") break;
+            expression += t.value + " ";
+            this.advance();
+          }
+          result.value = expression.trim();
+          result.isExpression = true;
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Parse orb declaration
+   */
+  parseOrb() {
+    const startToken = this.currentToken();
+    if (this.check("keyword", "orb") || this.check("keyword", "object")) {
+      this.advance();
+    } else {
+      this.expect("keyword", "orb");
+    }
+    let name = "";
+    if (this.check("punctuation", "#")) {
+      this.advance();
+      name = this.expectName() || `orb_${Date.now()}`;
+    } else {
+      name = this.expectName() || `orb_${Date.now()}`;
+    }
+    let template;
+    if (this.check("keyword", "using")) {
+      this.advance();
+      template = this.expectName() || void 0;
+    }
+    const properties = {};
+    const directives = [];
+    let position;
+    let hologram;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        if (this.check("punctuation", ",") || this.check("punctuation", ";")) {
+          this.advance();
+          continue;
+        }
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const directive = this.parseDirective();
+          if (directive) directives.push(directive);
+        } else {
+          const prop = this.parseProperty();
+          if (prop) {
+            if (prop.key === "position" || prop.key === "at") {
+              position = this.parsePosition(prop.value);
+            } else if (prop.key === "color" || prop.key === "glow" || prop.key === "size") {
+              hologram = hologram || {
+                shape: "orb",
+                color: "#00ffff",
+                size: 0.5,
+                glow: true,
+                interactive: true
+              };
+              if (prop.key === "color") hologram.color = String(prop.value);
+              if (prop.key === "glow") hologram.glow = Boolean(prop.value);
+              if (prop.key === "size") hologram.size = Number(prop.value);
+            } else {
+              properties[prop.key] = prop.value;
+            }
+          } else {
+            this.advance();
+          }
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "orb",
+      name,
+      position: position || [0, 0, 0],
+      hologram: hologram || {
+        shape: "orb",
+        color: "#00ffff",
+        size: 0.5,
+        glow: true,
+        interactive: true
+      },
+      properties,
+      directives,
+      template,
+      methods: [],
+      children: [],
+      line: startToken?.line || 0
+    };
+  }
+  /**
+   * Parse HoloScript+ directive: @name(...) or @name { ... }
+   */
+  parseDirective() {
+    this.expect("punctuation", "@");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    if (name === "state") {
+      const body = this.parseObject();
+      return { type: "state", body };
+    }
+    if (name === "bindings") {
+      const bindings = this.parseBindingsBlock();
+      return { type: "bindings", bindings };
+    }
+    if (name.startsWith("on_")) {
+      let body = "";
+      if (this.check("punctuation", "{")) {
+        this.advance();
+        let braceDepth = 1;
+        while (braceDepth > 0 && this.position < this.tokens.length) {
+          const t = this.advance();
+          if (t.value === "{") braceDepth++;
+          if (t.value === "}") braceDepth--;
+          if (braceDepth > 0) {
+            const val = t.type === "string" ? JSON.stringify(t.value) : t.value;
+            body += val + " ";
+          } else if (braceDepth < 0) break;
+        }
+      } else {
+        const t = this.advance();
+        if (t) body = t.value;
+      }
+      return { type: "lifecycle", hook: name, body };
+    }
+    let config = {};
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const prop = this.parseProperty();
+        if (prop) {
+          config[prop.key] = prop.value;
+        }
+        if (this.check("punctuation", ",")) {
+          this.advance();
+        }
+      }
+      this.expect("punctuation", ")");
+    } else if (this.check("punctuation", "{")) {
+      config = this.parseObject();
+    }
+    return { type: "trait", name, config };
+  }
+  /**
+   * Parse @bindings { bind(expr) -> target.prop, ... }
+   */
+  parseBindingsBlock() {
+    const bindings = [];
+    if (!this.check("punctuation", "{")) {
+      return bindings;
+    }
+    this.advance();
+    while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+      this.skipNewlines();
+      if (this.check("identifier") && this.currentToken()?.value === "bind") {
+        this.advance();
+        let expression = "";
+        if (this.check("punctuation", "(")) {
+          this.advance();
+          let parenDepth = 1;
+          while (parenDepth > 0 && this.position < this.tokens.length) {
+            const t = this.advance();
+            if (t.value === "(") parenDepth++;
+            if (t.value === ")") parenDepth--;
+            if (parenDepth > 0) {
+              expression += t.value + " ";
+            }
+          }
+          expression = expression.trim();
+        }
+        if (this.check("punctuation", "-")) {
+          this.advance();
+          if (this.check("punctuation", ">")) {
+            this.advance();
+          }
+        }
+        const target = this.expectIdentifier() || "";
+        let property = "";
+        if (this.check("punctuation", ".")) {
+          this.advance();
+          property = this.expectIdentifier() || "";
+        }
+        if (expression && target && property) {
+          bindings.push({ expression, target, property });
+        }
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    this.expect("punctuation", "}");
+    return bindings;
+  }
+  // ============================================================================
+  // Phase 7: AI Persistence Memory Syntax
+  // ============================================================================
+  /**
+   * Parse memory primitive block
+   * memory <Name> { semantic: SemanticMemory { ... }, episodic: EpisodicMemory { ... }, procedural: ProceduralMemory { ... } }
+   *
+   * Defers to the modular HoloScriptPersistenceParser
+   */
+  parseMemory() {
+    return this.persistenceParser.parseMemory();
+  }
+  /**
+   * Parse function declaration
+   */
+  parseFunction() {
+    this.expect("keyword", "function");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    const parameters = [];
+    let returnType;
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const paramName = this.expectIdentifier();
+        if (!paramName) break;
+        let paramType = "any";
+        if (this.check("punctuation", ":")) {
+          this.advance();
+          paramType = this.expectIdentifier() || "any";
+        }
+        parameters.push({
+          type: "parameter",
+          name: paramName,
+          dataType: paramType
+        });
+        if (this.check("punctuation", ",")) {
+          this.advance();
+        }
+      }
+      this.expect("punctuation", ")");
+    }
+    if (this.check("punctuation", ":")) {
+      this.advance();
+      returnType = this.expectIdentifier() || void 0;
+    }
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) depth++;
+        if (this.check("punctuation", "}")) depth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "method",
+      name,
+      parameters,
+      body,
+      returnType,
+      position: [0, 0, 0],
+      hologram: { shape: "cube", color: "#ff6b35", size: 1.5, glow: true, interactive: true }
+    };
+  }
+  /**
+   * Parse connection
+   */
+  parseConnection() {
+    this.expect("keyword", "connect");
+    const from = this.expectIdentifier();
+    if (!from) return null;
+    this.expect("keyword", "to");
+    const to = this.expectIdentifier();
+    if (!to) return null;
+    let dataType = "any";
+    if (this.check("keyword", "as")) {
+      this.advance();
+      const typeStr = this.currentToken();
+      if (typeStr?.type === "string" || typeStr?.type === "identifier") {
+        dataType = typeStr.value;
+        this.advance();
+      }
+    }
+    return {
+      type: "connection",
+      from,
+      to,
+      dataType,
+      bidirectional: false
+    };
+  }
+  /**
+   * Parse scale block: scale <magnitude> { body }
+   */
+  parseScale() {
+    this.expect("keyword", "scale");
+    const magnitude = this.expectIdentifier() || "standard";
+    const multipliers = {
+      galactic: 1e6,
+      macro: 1e3,
+      standard: 1,
+      micro: 1e-3,
+      atomic: 1e-6
+    };
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) body.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "scale",
+      magnitude,
+      multiplier: multipliers[magnitude] || 1,
+      body,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse focus block: focus <target> { body }
+   */
+  parseFocus() {
+    this.expect("keyword", "focus");
+    const target = this.expectIdentifier() || "origin";
+    const body = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) body.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "focus",
+      target,
+      body,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse environment declaration
+   * Supports: environment { ... } or environment #id { ... }
+   */
+  parseEnvironment() {
+    this.expect("keyword", "environment");
+    const settings = {};
+    let envId;
+    if (this.check("punctuation", "#")) {
+      this.advance();
+      envId = this.expectIdentifier() || void 0;
+    }
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        if (this.check("punctuation", "@")) {
+          const directive = this.parseDirective();
+          if (directive) {
+            const dir = directive;
+            settings[`@${directive.type}`] = dir.args || dir.config || [];
+          }
+          continue;
+        }
+        const prop = this.parseProperty();
+        if (prop) {
+          settings[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    } else {
+      while (this.position < this.tokens.length && this.currentToken()?.type !== "newline" && !this.check("punctuation", "}")) {
+        const key = this.expectIdentifier();
+        if (!key) break;
+        settings[key] = this.parseLiteral();
+      }
+    }
+    if (envId) {
+      settings["id"] = envId;
+    }
+    return {
+      type: "environment",
+      settings
+    };
+  }
+  /**
+   * Parse primitive 3D shape declaration
+   * Supports: cylinder #id { ... }, sphere "name" { ... }, etc.
+   */
+  parsePrimitive() {
+    const startToken = this.currentToken();
+    const primitiveType = startToken?.value || "object";
+    this.advance();
+    let name = "";
+    let elementId;
+    if (this.check("punctuation", "#")) {
+      this.advance();
+      elementId = this.expectIdentifier() || void 0;
+      name = elementId || `${primitiveType}_${Date.now()}`;
+    } else {
+      name = this.expectName() || `${primitiveType}_${Date.now()}`;
+    }
+    let template;
+    if (this.check("keyword", "using")) {
+      this.advance();
+      template = this.expectName() || void 0;
+    }
+    const properties = {};
+    const directives = [];
+    let position;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        if (this.check("punctuation", ",") || this.check("punctuation", ";")) {
+          this.advance();
+          continue;
+        }
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const directive = this.parseDirective();
+          if (directive) directives.push(directive);
+        } else {
+          const prop = this.parseProperty();
+          if (prop) {
+            if (prop.key === "position" || prop.key === "at") {
+              position = this.parsePosition(prop.value);
+            } else {
+              properties[prop.key] = prop.value;
+            }
+          } else {
+            this.advance();
+          }
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    properties["_primitiveType"] = primitiveType;
+    if (elementId) {
+      properties["id"] = elementId;
+    }
+    return {
+      type: "orb",
+      name,
+      position: position || [0, 0, 0],
+      hologram: {
+        shape: primitiveType,
+        color: "#00d4ff",
+        size: 1,
+        glow: false,
+        interactive: true
+      },
+      properties,
+      directives,
+      template,
+      methods: [],
+      children: [],
+      line: startToken?.line || 0
+    };
+  }
+  /**
+   * Parse zone declaration: zone "Name" { ... } or zone #id { ... }
+   */
+  parseZone() {
+    this.expect("keyword", "zone");
+    let name = "";
+    let zoneId;
+    if (this.check("punctuation", "#")) {
+      this.advance();
+      zoneId = this.expectIdentifier() || void 0;
+      name = zoneId || `zone_${Date.now()}`;
+    } else {
+      name = this.expectName() || `zone_${Date.now()}`;
+    }
+    const properties = {};
+    let position;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const prop = this.parseProperty();
+        if (prop) {
+          if (prop.key === "position") {
+            position = this.parsePosition(prop.value);
+            properties["position"] = prop.value;
+          } else {
+            properties[prop.key] = prop.value;
+          }
+        } else {
+          const token = this.currentToken();
+          this.addError(
+            this.createError(
+              "HS004",
+              `Unexpected token in zone: ${token?.type || "unknown"}`,
+              token
+            )
+          );
+          this.advance();
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "zone",
+      name,
+      id: zoneId,
+      position,
+      events: {},
+      // Events are stored in properties for now
+      properties
+    };
+  }
+  /**
+   * Parse composition block
+   */
+  parseComposition() {
+    this.expect("keyword", "composition");
+    const name = this.expectName() || "unnamed";
+    const children = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const node = this.parseDeclaration();
+        if (node) children.push(node);
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "composition",
+      name,
+      children
+    };
+  }
+  /**
+   * Parse template declaration
+   */
+  parseTemplate() {
+    this.expect("keyword", "template");
+    const name = this.expectName() || "template";
+    let version;
+    const params = [];
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const p = this.expectIdentifier();
+        if (p) params.push(p);
+        if (this.check("punctuation", ",")) this.advance();
+      }
+      this.expect("punctuation", ")");
+    }
+    const children = [];
+    const migrations = [];
+    const directives = [];
+    const properties = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const startPos2 = this.position;
+          this.advance();
+          const dirName = this.expectIdentifier();
+          if (dirName === "version") {
+            this.expect("punctuation", "(");
+            const vStr = this.currentToken();
+            if (vStr?.type === "number") {
+              version = parseInt(vStr.value, 10);
+              this.advance();
+            }
+            this.expect("punctuation", ")");
+            directives.push({ type: "version", version });
+            this.skipNewlines();
+            continue;
+          } else {
+            this.position = startPos2;
+            const dir = this.parseDirective();
+            if (dir) directives.push(dir);
+            this.skipNewlines();
+            continue;
+          }
+        }
+        const startPos = this.position;
+        const errorCount = this.errors.length;
+        const node = this.parseDeclaration();
+        if (node && node.type !== "expression") {
+          if (node.type === "migration") {
+            migrations.push(node);
+          } else {
+            children.push(node);
+          }
+          this.skipNewlines();
+          continue;
+        }
+        this.position = startPos;
+        this.errors.length = errorCount;
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+          this.skipNewlines();
+          continue;
+        }
+        this.advance();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "template",
+      name,
+      parameters: params,
+      children,
+      properties,
+      directives,
+      version,
+      migrations
+    };
+  }
+  /**
+   * Parse system declaration: system Name { state {}, on_start {}, action name() {}, ui {} }
+   *
+   * Systems are named trait+logic containers that auto-initialize within a composition.
+   * They encapsulate state, lifecycle hooks, actions, and optional UI.
+   *
+   * Syntax:
+   *   system TutorialSystem {
+   *     state { currentStep: 0, completed: false }
+   *     on_start { ... }
+   *     on_update { ... }
+   *     action next() { ... }
+   *     action skip() { ... }
+   *     ui { ... }
+   *   }
+   */
+  parseSystem() {
+    this.expect("keyword", "system");
+    const name = this.expectName() || "unnamed_system";
+    const state = {};
+    const actions = [];
+    const hooks = [];
+    const directives = [];
+    const properties = {};
+    const children = [];
+    const uiNodes = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const directive = this.parseDirective();
+          if (directive) directives.push(directive);
+          this.skipNewlines();
+          continue;
+        }
+        if (token?.type === "keyword" || token?.type === "identifier") {
+          const val = token.value.toLowerCase();
+          if (val === "state") {
+            this.advance();
+            if (this.check("punctuation", "{")) {
+              const stateObj = this.parseObject();
+              Object.assign(state, stateObj);
+            }
+            this.skipNewlines();
+            continue;
+          }
+          if (val === "action") {
+            this.advance();
+            const actionName = this.expectIdentifier();
+            if (actionName) {
+              const params = [];
+              if (this.check("punctuation", "(")) {
+                this.advance();
+                while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+                  const p = this.expectIdentifier();
+                  if (p) params.push(p);
+                  if (this.check("punctuation", ",")) this.advance();
+                }
+                this.expect("punctuation", ")");
+              }
+              const body = this.parseBlockBody();
+              actions.push({ name: actionName, params, body });
+            }
+            this.skipNewlines();
+            continue;
+          }
+          if (val.startsWith("on_")) {
+            this.advance();
+            const body = this.parseBlockBody();
+            hooks.push({ name: val, body });
+            this.skipNewlines();
+            continue;
+          }
+          if (val === "ui") {
+            this.advance();
+            if (this.check("punctuation", "{")) {
+              this.advance();
+              while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+                this.skipNewlines();
+                const node2 = this.parseDeclaration();
+                if (node2) uiNodes.push(node2);
+                this.skipNewlines();
+              }
+              this.expect("punctuation", "}");
+            }
+            this.skipNewlines();
+            continue;
+          }
+          const startPos = this.position;
+          const errorCount = this.errors.length;
+          const node = this.parseDeclaration();
+          if (node && node.type !== "expression") {
+            children.push(node);
+            this.skipNewlines();
+            continue;
+          }
+          this.position = startPos;
+          this.errors.length = errorCount;
+          const prop = this.parseProperty();
+          if (prop) {
+            properties[prop.key] = prop.value;
+            this.skipNewlines();
+            continue;
+          }
+        }
+        this.advance();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "system",
+      id: name,
+      properties,
+      state: Object.keys(state).length > 0 ? state : void 0,
+      actions: actions.length > 0 ? actions : void 0,
+      hooks: hooks.length > 0 ? hooks : void 0,
+      ui: uiNodes.length > 0 ? uiNodes : void 0,
+      children: children.length > 0 ? children : void 0,
+      directives: directives.length > 0 ? directives : void 0
+    };
+  }
+  /**
+   * Parse component declaration: component Name { props {}, state {}, ui {}, action name() {} }
+   *
+   * Components are UI-focused declarations with props, state, and render/ui blocks.
+   *
+   * Syntax:
+   *   component MobileControls {
+   *     props { visible: true, joystickSize: 120 }
+   *     state { isMoving: false }
+   *     ui { ... }
+   *   }
+   */
+  parseComponent() {
+    this.expect("keyword", "component");
+    const name = this.expectName() || "unnamed_component";
+    const props = {};
+    const state = {};
+    const actions = [];
+    const hooks = [];
+    const directives = [];
+    const properties = {};
+    const children = [];
+    const uiNodes = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const token = this.currentToken();
+        if (token?.type === "punctuation" && token.value === "@") {
+          const directive = this.parseDirective();
+          if (directive) directives.push(directive);
+          this.skipNewlines();
+          continue;
+        }
+        if (token?.type === "keyword" || token?.type === "identifier") {
+          const val = token.value.toLowerCase();
+          if (val === "props") {
+            this.advance();
+            if (this.check("punctuation", "{")) {
+              const propsObj = this.parseObject();
+              Object.assign(props, propsObj);
+            }
+            this.skipNewlines();
+            continue;
+          }
+          if (val === "state") {
+            this.advance();
+            if (this.check("punctuation", "{")) {
+              const stateObj = this.parseObject();
+              Object.assign(state, stateObj);
+            }
+            this.skipNewlines();
+            continue;
+          }
+          if (val === "action") {
+            this.advance();
+            const actionName = this.expectIdentifier();
+            if (actionName) {
+              const params = [];
+              if (this.check("punctuation", "(")) {
+                this.advance();
+                while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+                  const p = this.expectIdentifier();
+                  if (p) params.push(p);
+                  if (this.check("punctuation", ",")) this.advance();
+                }
+                this.expect("punctuation", ")");
+              }
+              const body = this.parseBlockBody();
+              actions.push({ name: actionName, params, body });
+            }
+            this.skipNewlines();
+            continue;
+          }
+          if (val.startsWith("on_")) {
+            this.advance();
+            const body = this.parseBlockBody();
+            hooks.push({ name: val, body });
+            this.skipNewlines();
+            continue;
+          }
+          if (val === "ui") {
+            this.advance();
+            if (this.check("punctuation", "{")) {
+              this.advance();
+              while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+                this.skipNewlines();
+                const node2 = this.parseDeclaration();
+                if (node2) uiNodes.push(node2);
+                this.skipNewlines();
+              }
+              this.expect("punctuation", "}");
+            }
+            this.skipNewlines();
+            continue;
+          }
+          const startPos = this.position;
+          const errorCount = this.errors.length;
+          const node = this.parseDeclaration();
+          if (node && node.type !== "expression") {
+            children.push(node);
+            this.skipNewlines();
+            continue;
+          }
+          this.position = startPos;
+          this.errors.length = errorCount;
+          const prop = this.parseProperty();
+          if (prop) {
+            properties[prop.key] = prop.value;
+            this.skipNewlines();
+            continue;
+          }
+        }
+        this.advance();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "component",
+      name,
+      props: Object.keys(props).length > 0 ? props : void 0,
+      state: Object.keys(state).length > 0 ? state : void 0,
+      actions: actions.length > 0 ? actions : void 0,
+      hooks: hooks.length > 0 ? hooks : void 0,
+      ui: uiNodes.length > 0 ? uiNodes : void 0,
+      children: children.length > 0 ? children : void 0,
+      directives: directives.length > 0 ? directives : void 0,
+      properties: Object.keys(properties).length > 0 ? properties : void 0
+    };
+  }
+  /**
+   * Parse a block body { ... } — captures everything between braces as a string.
+   * Used for action bodies and lifecycle hooks where we capture the raw body.
+   */
+  parseBlockBody() {
+    let body = "";
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let braceDepth = 1;
+      while (braceDepth > 0 && this.position < this.tokens.length) {
+        const t = this.advance();
+        if (t.value === "{") braceDepth++;
+        if (t.value === "}") braceDepth--;
+        if (braceDepth > 0) {
+          const val = t.type === "string" ? JSON.stringify(t.value) : t.value;
+          body += val + " ";
+        }
+      }
+    }
+    return body.trim();
+  }
+  /**
+   * Parse migration block: migrate from(n) { body }
+   */
+  parseMigration() {
+    this.expect("keyword", "migrate");
+    this.expect("keyword", "from");
+    this.expect("punctuation", "(");
+    let fromVersion = 0;
+    const vStr = this.currentToken();
+    if (vStr?.type === "number") {
+      fromVersion = parseInt(vStr.value, 10);
+      this.advance();
+    }
+    this.expect("punctuation", ")");
+    let body = "";
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let braceDepth = 1;
+      this.position;
+      while (braceDepth > 0 && this.position < this.tokens.length) {
+        const t = this.advance();
+        if (t.value === "{") braceDepth++;
+        if (t.value === "}") braceDepth--;
+        if (braceDepth > 0) {
+          const val = t.type === "string" ? JSON.stringify(t.value) : t.value;
+          body += val + " ";
+        }
+      }
+    }
+    return {
+      type: "migration",
+      fromVersion,
+      body: body.trim(),
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse gate (conditional)
+   */
+  parseGate() {
+    const isIf = this.check("keyword", "if");
+    if (isIf) {
+      this.advance();
+    } else {
+      this.expect("keyword", "gate");
+      this.expectIdentifier();
+    }
+    let condition = "";
+    if (this.check("punctuation", "(")) {
+      this.advance();
+      while (!this.check("punctuation", ")") && this.position < this.tokens.length) {
+        const token = this.currentToken();
+        if (token) condition += token.value + " ";
+        this.advance();
+      }
+      this.expect("punctuation", ")");
+    }
+    const truePath = [];
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        const node = this.parseDeclaration();
+        if (node) truePath.push(node);
+        else this.advance();
+      }
+      this.expect("punctuation", "}");
+    }
+    const falsePath = [];
+    if (this.check("keyword", "else")) {
+      this.advance();
+      if (this.check("punctuation", "{")) {
+        this.advance();
+        while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+          const node = this.parseDeclaration();
+          if (node) falsePath.push(node);
+          else this.advance();
+        }
+        this.expect("punctuation", "}");
+      } else {
+        const node = this.parseDeclaration();
+        if (node) falsePath.push(node);
+      }
+    }
+    return {
+      type: "gate",
+      condition: this.parseConditionExpression(condition.trim()),
+      truePath,
+      falsePath,
+      position: [0, 0, 0],
+      hologram: { shape: "pyramid", color: "#4ecdc4", size: 1, glow: true, interactive: true }
+    };
+  }
+  /**
+   * Parse return statement
+   */
+  parseReturn() {
+    this.expect("keyword", "return");
+    let expression = "";
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    while (this.position < this.tokens.length) {
+      const t = this.currentToken();
+      if (!t) break;
+      if (t.type === "newline" && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) break;
+      if (t.type === "punctuation" && t.value === ";" && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0)
+        break;
+      if (t.type === "punctuation") {
+        if (t.value === "(") parenDepth++;
+        else if (t.value === ")") parenDepth--;
+        else if (t.value === "{") braceDepth++;
+        else if (t.value === "}") braceDepth--;
+        else if (t.value === "[") bracketDepth++;
+        else if (t.value === "]") bracketDepth--;
+      }
+      expression += t.value + " ";
+      this.advance();
+    }
+    return {
+      type: "return",
+      value: expression.trim(),
+      // Use 'value' to match runtime's executeReturn
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse generic expression statement (e.g. function call or assignment)
+   */
+  parseExpressionStatement() {
+    let expression = "";
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    while (this.position < this.tokens.length) {
+      const t = this.currentToken();
+      if (!t) break;
+      if (t.type === "newline" && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0) break;
+      if (t.type === "punctuation" && t.value === ";" && parenDepth === 0 && braceDepth === 0 && bracketDepth === 0)
+        break;
+      if (t.type === "punctuation") {
+        if (t.value === "(") parenDepth++;
+        else if (t.value === ")") parenDepth--;
+        else if (t.value === "{") braceDepth++;
+        else if (t.value === "}") braceDepth--;
+        else if (t.value === "[") bracketDepth++;
+        else if (t.value === "]") bracketDepth--;
+      }
+      expression += t.value + " ";
+      this.advance();
+    }
+    if (expression.trim().length === 0) {
+      this.advance();
+      return null;
+    }
+    return {
+      type: "expression-statement",
+      expression: expression.trim(),
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse stream
+   */
+  parseStream() {
+    this.expect("keyword", "stream");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    let source = "unknown";
+    if (this.check("keyword", "from")) {
+      this.advance();
+      source = this.expectIdentifier() || "unknown";
+    }
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) depth++;
+        if (this.check("punctuation", "}")) depth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "stream",
+      name,
+      source,
+      transformations: [],
+      position: [0, 0, 0],
+      hologram: { shape: "cylinder", color: "#45b7d1", size: 2, glow: true, interactive: true }
+    };
+  }
+  /**
+   * Parse nexus (multi-agent hub)
+   */
+  parseNexus() {
+    this.expect("keyword", "nexus");
+    const name = this.expectIdentifier();
+    if (!name) return null;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) depth++;
+        if (this.check("punctuation", "}")) depth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "nexus",
+      position: [0, 0, 0],
+      hologram: { shape: "sphere", color: "#9b59b6", size: 3, glow: true, interactive: true }
+    };
+  }
+  /**
+   * Parse building (class-like)
+   */
+  parseBuilding() {
+    this.expect("keyword", "building");
+    const name = this.expectName();
+    if (!name) return null;
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      let depth = 1;
+      while (depth > 0 && this.position < this.tokens.length) {
+        if (this.check("punctuation", "{")) depth++;
+        if (this.check("punctuation", "}")) depth--;
+        this.advance();
+      }
+    }
+    return {
+      type: "building",
+      position: [0, 0, 0],
+      hologram: { shape: "cube", color: "#e74c3c", size: 4, glow: true, interactive: true }
+    };
+  }
+  /**
+   * Parse a literal value (string, number, boolean, array, or object)
+   */
+  parseLiteral() {
+    const token = this.currentToken();
+    if (!token) return null;
+    if (token.type === "string") {
+      this.advance();
+      return token.value;
+    }
+    if (token.type === "number") {
+      this.advance();
+      return parseFloat(token.value);
+    }
+    if (token.type === "identifier") {
+      const val = token.value.toLowerCase();
+      this.advance();
+      if (val === "true") return true;
+      if (val === "false") return false;
+      if (val === "null") return null;
+      return token.value;
+    }
+    if (this.check("punctuation", "[")) {
+      return this.parseArray();
+    }
+    if (this.check("punctuation", "{")) {
+      return this.parseObject();
+    }
+    this.advance();
+    return token.value;
+  }
+  /**
+   * Parse a property (key: value)
+   */
+  parseProperty() {
+    const key = this.expectIdentifier();
+    if (!key) return null;
+    if (!this.check("punctuation", ":")) {
+      return { key, value: true };
+    }
+    this.advance();
+    const value = this.parseLiteral();
+    return { key, value };
+  }
+  /**
+   * Parse array [...]
+   */
+  parseArray() {
+    const arr = [];
+    this.expect("punctuation", "[");
+    while (!this.check("punctuation", "]") && this.position < this.tokens.length) {
+      const token = this.currentToken();
+      if (token?.type === "string" || token?.type === "number" || token?.type === "identifier") {
+        if (token.type === "number") {
+          arr.push(parseFloat(token.value));
+        } else {
+          arr.push(token.value);
+        }
+        this.advance();
+      } else if (this.check("punctuation", ",")) {
+        this.advance();
+      } else {
+        this.addError(
+          this.createError("HS004", `Unexpected token in array: ${token?.type || "unknown"}`, token)
+        );
+        this.advance();
+      }
+    }
+    this.expect("punctuation", "]");
+    return arr;
+  }
+  /**
+   * Parse object {...}
+   */
+  parseObject() {
+    const obj = {};
+    this.expect("punctuation", "{");
+    while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+      this.skipNewlines();
+      if (this.check("punctuation", "}")) break;
+      const prop = this.parseProperty();
+      if (prop) {
+        obj[prop.key] = prop.value;
+      } else {
+        const token = this.currentToken();
+        this.addError(
+          this.createError(
+            "HS004",
+            `Unexpected token in object: ${token?.type || "unknown"}`,
+            token
+          )
+        );
+        this.advance();
+      }
+      this.skipNewlines();
+      if (this.check("punctuation", ",")) {
+        this.advance();
+      }
+    }
+    this.expect("punctuation", "}");
+    return obj;
+  }
+  /**
+   * Parse position from value
+   */
+  parsePosition(value) {
+    if (Array.isArray(value)) {
+      return [
+        Number(value[0]) || 0,
+        Number(value[1]) || 0,
+        Number(value[2]) || 0
+      ];
+    }
+    if (typeof value === "object" && value !== null) {
+      const v = value;
+      const x = Number(v[0] !== void 0 ? v[0] : v[0]) || 0;
+      const y = Number(v[1] !== void 0 ? v[1] : v[1]) || 0;
+      const z = Number(v[2] !== void 0 ? v[2] : v[2]) || 0;
+      return [x, y, z];
+    }
+    return [0, 0, 0];
+  }
+  // Helper methods
+  currentToken() {
+    return this.tokens[this.position];
+  }
+  advance() {
+    return this.tokens[this.position++];
+  }
+  check(type, value) {
+    const token = this.currentToken();
+    if (!token) return false;
+    if (token.type !== type) return false;
+    if (value !== void 0 && token.value.toLowerCase() !== value.toLowerCase()) return false;
+    return true;
+  }
+  expect(type, value) {
+    if (this.check(type, value)) {
+      this.advance();
+      return true;
+    }
+    const token = this.currentToken();
+    let suggestion;
+    if (type === "keyword" && value && token?.type === "identifier") {
+      const similar = this.findSimilarKeyword(token.value);
+      if (similar) {
+        suggestion = `Did you mean '${similar}'?`;
+      }
+    }
+    this.addError(
+      this.createError(
+        type === "keyword" ? "HS001" : type === "identifier" ? "HS002" : "HS003",
+        `Expected ${type}${value ? ` '${value}'` : ""}, got ${token?.type || "EOF"} '${token?.value || ""}'`,
+        token,
+        suggestion
+      )
+    );
+    return false;
+  }
+  expectIdentifier() {
+    const token = this.currentToken();
+    if (token && (token.type === "identifier" || token.type === "keyword")) {
+      this.advance();
+      return token.value;
+    }
+    this.addError(
+      this.createError(
+        "HS002",
+        `Expected identifier, got ${token?.type || "EOF"}`,
+        token,
+        token?.type === "number" ? "Identifiers cannot start with a number" : void 0
+      )
+    );
+    return null;
+  }
+  /**
+   * Expect an identifier OR a string literal for named declarations
+   * Allows both: composition MyScene { } and composition "MyScene" { }
+   */
+  expectName() {
+    const token = this.currentToken();
+    if (token?.type === "identifier" || token?.type === "keyword") {
+      this.advance();
+      return token.value;
+    }
+    if (token?.type === "string") {
+      this.advance();
+      const val = token.value;
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        return val.slice(1, -1);
+      }
+      return val;
+    }
+    this.addError(
+      this.createError(
+        "HS002",
+        `Expected name (identifier or string), got ${token?.type || "EOF"}`,
+        token
+      )
+    );
+    return null;
+  }
+  /**
+   * Parse animate command: animate target property: "..." from: 0 to: 1 duration: 1000
+   */
+  parseAnimate() {
+    this.expect("keyword", "animate");
+    const target = this.expectIdentifier();
+    if (!target) return null;
+    const properties = {};
+    while (this.position < this.tokens.length) {
+      this.skipNewlines();
+      const t = this.currentToken();
+      if (!t || t.type === "newline" || t.type === "keyword" && this.keywordSet.has(t.value.toLowerCase()))
+        break;
+      const prop = this.parseProperty();
+      if (prop) {
+        properties[prop.key] = prop.value;
+      } else {
+        break;
+      }
+    }
+    return {
+      type: "expression-statement",
+      expression: `animate("${target}", ${JSON.stringify(properties)})`,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse modify command: modify target { prop: value }
+   */
+  parseModify() {
+    this.expect("keyword", "modify");
+    const target = this.expectIdentifier();
+    if (!target) return null;
+    const properties = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "expression-statement",
+      expression: `modify("${target}", ${JSON.stringify(properties)})`,
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse UI Element: ui2d dashboard#id { ... }
+   */
+  parseUIElement() {
+    const typeToken = this.currentToken();
+    if (!typeToken) return null;
+    const elementType = typeToken.value;
+    this.advance();
+    let elementId = `${elementType}_${Date.now()}`;
+    const token = this.currentToken();
+    if (token?.type === "punctuation" && token.value === "#") {
+      this.advance();
+      const idToken = this.currentToken();
+      if (idToken) {
+        elementId = idToken.value;
+        this.advance();
+      }
+    } else if (token?.type === "identifier" && token.value.startsWith("#")) {
+      elementId = token.value.slice(1) || elementId;
+      this.advance();
+    }
+    const properties = {};
+    if (this.check("punctuation", "{")) {
+      this.advance();
+      while (!this.check("punctuation", "}") && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check("punctuation", "}")) break;
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect("punctuation", "}");
+    }
+    return {
+      type: "ui2d",
+      name: elementType,
+      properties: { id: elementId, ...properties },
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse settings command: settings
+   */
+  parseSettings() {
+    this.expect("keyword", "settings");
+    return {
+      type: "expression-statement",
+      expression: "showSettings()",
+      position: [0, 0, 0]
+    };
+  }
+  parseChat() {
+    this.expect("keyword", "chat");
+    return {
+      type: "expression-statement",
+      expression: "openChat()",
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Parse a condition string into a structured TypeGuardExpression if applicable,
+   * otherwise returns the string as-is.
+   */
+  parseConditionExpression(condition) {
+    const isPattern = /^([a-zA-Z_][a-zA-Z0-9_]*)\s+is\s+["']([^"']+)["']$/;
+    const match = condition.match(isPattern);
+    if (match) {
+      return {
+        type: "type-guard",
+        subject: match[1],
+        guardType: match[2],
+        line: 0,
+        // Simplified for now
+        column: 0
+      };
+    }
+    return condition;
+  }
+  skipNewlines() {
+    while (this.currentToken()?.type === "newline") {
+      this.advance();
+    }
+  }
+};
+
+exports.ERROR_CODES = ERROR_CODES;
+exports.HoloScriptCodeParser = HoloScriptCodeParser;
+exports.ParserPools = ParserPools;
+//# sourceMappingURL=chunk-JIYN45TV.cjs.map
+//# sourceMappingURL=chunk-JIYN45TV.cjs.map