@holoscript/core 6.0.3 → 7.0.0

package/dist/chunk-EPWRXL6S.js

@@ -1,2522 +0,0 @@
-import { logger } from './chunk-PHENW4MQ.js';
-
-// 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 0 }
-              };
-            } else if (key === "episodic" && typeToken.value === "EpisodicMemory") {
-              node.episodic = {
-                type: "episodic-memory",
-                properties,
-                position: { x: 0, y: 0, z: 0 }
-              };
-            } else if (key === "procedural" && typeToken.value === "ProceduralMemory") {
-              node.procedural = {
-                type: "procedural-memory",
-                properties,
-                position: { x: 0, y: 0, z: 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)) {
-        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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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 || { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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 || { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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 {
-        x: Number(value[0]) || 0,
-        y: Number(value[1]) || 0,
-        z: Number(value[2]) || 0
-      };
-    }
-    if (typeof value === "object" && value !== null) {
-      const v = value;
-      return {
-        x: Number(v.x) || 0,
-        y: Number(v.y) || 0,
-        z: Number(v.z) || 0
-      };
-    }
-    return { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 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: { x: 0, y: 0, z: 0 }
-    };
-  }
-  /**
-   * Parse settings command: settings
-   */
-  parseSettings() {
-    this.expect("keyword", "settings");
-    return {
-      type: "expression-statement",
-      expression: "showSettings()",
-      position: { x: 0, y: 0, z: 0 }
-    };
-  }
-  parseChat() {
-    this.expect("keyword", "chat");
-    return {
-      type: "expression-statement",
-      expression: "openChat()",
-      position: { x: 0, y: 0, z: 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();
-    }
-  }
-};
-
-export { ERROR_CODES, HoloScriptCodeParser, ParserPools };
-//# sourceMappingURL=chunk-EPWRXL6S.js.map
-//# sourceMappingURL=chunk-EPWRXL6S.js.map