eny-ai 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3235 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn2, res) => function __init() {
+  return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lexer/tokenize.ts
+function isWhitespace(ch) {
+  return ch === " " || ch === "	" || ch === "\r";
+}
+function isNewline(ch) {
+  return ch === "\n";
+}
+function isDigit(ch) {
+  return /[0-9]/.test(ch);
+}
+function isIdentifierStart(ch) {
+  return /[A-Za-z_\p{L}]/u.test(ch);
+}
+function isIdentifierPart(ch) {
+  return /[A-Za-z0-9_\p{L}]/u.test(ch);
+}
+function getCodePoint(str, pos) {
+  const code = str.codePointAt(pos);
+  if (code === void 0) return { char: "", len: 0 };
+  const char = String.fromCodePoint(code);
+  const len = code > 65535 ? 2 : 1;
+  return { char, len };
+}
+function tokenize(input) {
+  const tokens = [];
+  const len = input.length;
+  let i = 0;
+  while (i < len) {
+    const { char: ch, len: charLen } = getCodePoint(input, i);
+    if (charLen === 0) {
+      i++;
+      continue;
+    }
+    if (isWhitespace(ch)) {
+      i += charLen;
+      continue;
+    }
+    if (isNewline(ch)) {
+      tokens.push({ type: "NEWLINE" /* NEWLINE */, value: "\n", pos: i });
+      i += charLen;
+      continue;
+    }
+    if (SYMBOLS.has(ch)) {
+      tokens.push({ type: "SYMBOL" /* SYMBOL */, value: ch, pos: i });
+      i += charLen;
+      continue;
+    }
+    if (ch === "\u2192" || ch === "-" && input[i + 1] === ">") {
+      if (ch === "\u2192") {
+        tokens.push({ type: "ARROW" /* ARROW */, value: "\u2192", pos: i });
+        i++;
+      } else {
+        tokens.push({ type: "ARROW" /* ARROW */, value: "->", pos: i });
+        i += 2;
+      }
+      continue;
+    }
+    if (ch === "{") {
+      tokens.push({ type: "LBRACE" /* LBRACE */, value: "{", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "}") {
+      tokens.push({ type: "RBRACE" /* RBRACE */, value: "}", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "LPAREN" /* LPAREN */, value: "(", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "RPAREN" /* RPAREN */, value: ")", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "[") {
+      tokens.push({ type: "LBRACKET" /* LBRACKET */, value: "[", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "]") {
+      tokens.push({ type: "RBRACKET" /* RBRACKET */, value: "]", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ":") {
+      tokens.push({ type: "COLON" /* COLON */, value: ":", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === ",") {
+      tokens.push({ type: "COMMA" /* COMMA */, value: ",", pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "=" && input[i + 1] === "=" || ch === "!" && input[i + 1] === "=" || ch === ">" && input[i + 1] === "=" || ch === "<" && input[i + 1] === "=") {
+      tokens.push({ type: "COMPARATOR" /* COMPARATOR */, value: input.substr(i, 2), pos: i });
+      i += 2;
+      continue;
+    }
+    if (ch === ">" || ch === "<") {
+      tokens.push({ type: "COMPARATOR" /* COMPARATOR */, value: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch === "\u2260") {
+      tokens.push({ type: "COMPARATOR" /* COMPARATOR */, value: "\u2260", pos: i });
+      i++;
+      continue;
+    }
+    if (OPERATORS.has(ch) && !SYMBOLS.has(ch)) {
+      tokens.push({ type: "OPERATOR" /* OPERATOR */, value: ch, pos: i });
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      let out = "";
+      while (j < len) {
+        if (input[j] === "\\" && j + 1 < len) {
+          out += input[j + 1];
+          j += 2;
+          continue;
+        }
+        if (input[j] === '"') {
+          break;
+        }
+        out += input[j];
+        j++;
+      }
+      tokens.push({ type: "STRING" /* STRING */, value: out, pos: i });
+      i = j + 1;
+      continue;
+    }
+    if (isDigit(ch)) {
+      let j = i;
+      let val = "";
+      while (j < len && isDigit(input[j])) {
+        val += input[j];
+        j++;
+      }
+      tokens.push({ type: "NUMBER" /* NUMBER */, value: val, pos: i });
+      i = j;
+      continue;
+    }
+    if (isIdentifierStart(ch)) {
+      let j = i;
+      let val = "";
+      while (j < len && isIdentifierPart(input[j])) {
+        val += input[j];
+        j++;
+      }
+      tokens.push({ type: "IDENTIFIER" /* IDENTIFIER */, value: val, pos: i });
+      i = j;
+      continue;
+    }
+    tokens.push({ type: "IDENTIFIER" /* IDENTIFIER */, value: ch, pos: i });
+    i += charLen;
+  }
+  tokens.push({ type: "EOF" /* EOF */, value: "", pos: i });
+  return tokens;
+}
+var TokenType, SYMBOLS_STATE, SYMBOLS_EXEC, SYMBOLS_STRUCT, SYMBOLS_TIME, SYMBOLS_ENERGY, SYMBOLS_MEMORY, SYMBOLS_UI, SYMBOLS_SECURITY, SYMBOLS_EVOLVE, SYMBOLS_LOGIC, SYMBOLS, SYMBOL_NAMES, OPERATORS;
+var init_tokenize = __esm({
+  "src/lexer/tokenize.ts"() {
+    "use strict";
+    TokenType = /* @__PURE__ */ ((TokenType2) => {
+      TokenType2["SYMBOL"] = "SYMBOL";
+      TokenType2["IDENTIFIER"] = "IDENTIFIER";
+      TokenType2["STRING"] = "STRING";
+      TokenType2["NUMBER"] = "NUMBER";
+      TokenType2["ARROW"] = "ARROW";
+      TokenType2["LBRACE"] = "LBRACE";
+      TokenType2["RBRACE"] = "RBRACE";
+      TokenType2["COLON"] = "COLON";
+      TokenType2["COMMA"] = "COMMA";
+      TokenType2["LPAREN"] = "LPAREN";
+      TokenType2["RPAREN"] = "RPAREN";
+      TokenType2["LBRACKET"] = "LBRACKET";
+      TokenType2["RBRACKET"] = "RBRACKET";
+      TokenType2["NEWLINE"] = "NEWLINE";
+      TokenType2["COMPARATOR"] = "COMPARATOR";
+      TokenType2["OPERATOR"] = "OPERATOR";
+      TokenType2["EOF"] = "EOF";
+      return TokenType2;
+    })(TokenType || {});
+    SYMBOLS_STATE = /* @__PURE__ */ new Set([
+      "\u03A3",
+      // STATE - Estado global
+      "\u03C3",
+      // SUBSTATE - Estado local
+      "\xD8",
+      // VOID - Não-existência
+      "\u{1F512}",
+      // LOCK - Imutável
+      "\u{1F513}"
+      // UNLOCK - Mutável
+    ]);
+    SYMBOLS_EXEC = /* @__PURE__ */ new Set([
+      "\u0394",
+      // ACTION - Ação/função
+      "\u0192",
+      // FUNCTION - Capacidade lógica
+      "\u21C9",
+      // PARALLEL - Execução paralela
+      "\u25B3",
+      // DEPEND - Dependência
+      "\u25CF",
+      // CORE - Núcleo
+      "\u23F3"
+      // DELAY - Espera temporal
+    ]);
+    SYMBOLS_STRUCT = /* @__PURE__ */ new Set([
+      "\u03A9",
+      // OBJECT - Objeto
+      "\u25A0",
+      // OBJECT ALT - Entidade concreta
+      "\u25CB",
+      // CLASS - Classe/molde
+      "\u2B12",
+      // INHERIT - Herança
+      "\u2283",
+      // CONTAINS - Composição
+      "\u2254",
+      // ASSIGN - Atribuição
+      "\u29C9"
+      // MODULE - Módulo
+    ]);
+    SYMBOLS_TIME = /* @__PURE__ */ new Set([
+      "\u26A1",
+      // CAUSE - Causa/origem
+      "\u2726",
+      // CONSEQUENCE - Resultado
+      "\u21BB",
+      // LOOP - Repetição
+      "\u25CC",
+      // EVENT - Evento
+      "\u21C4",
+      // SYNC - Sincronização
+      "\u231B"
+      // TIMEOUT - Limite temporal
+    ]);
+    SYMBOLS_ENERGY = /* @__PURE__ */ new Set([
+      "\u03A8",
+      // ENERGY - Energia vital
+      "\u23EC",
+      // THROTTLE - Limitar
+      "\u23EB",
+      // BOOST - Acelerar
+      "\u20B5"
+      // COST - Custo
+    ]);
+    SYMBOLS_MEMORY = /* @__PURE__ */ new Set([
+      "\u{1D4DC}",
+      // MEMORY - Memória
+      "\u267E",
+      // PERSIST - Persistência
+      "\u2302"
+      // ROOT - Raiz do sistema
+    ]);
+    SYMBOLS_UI = /* @__PURE__ */ new Set([
+      "\u03A6",
+      // FORM - Form/UI
+      "\u0398",
+      // ANIMATION - Animação
+      "\u2610",
+      // INTERFACE - Interface
+      "\u{1F441}",
+      // VISUAL - Percepção visual
+      "\u2328",
+      // INPUT - Entrada
+      "\u{1F9ED}"
+      // POINTER - Ponteiro/direção
+    ]);
+    SYMBOLS_SECURITY = /* @__PURE__ */ new Set([
+      "\u{1F6E1}",
+      // SECURITY - Segurança
+      "\u{1F511}",
+      // KEY - Chave/autorização
+      "\u26A0",
+      // RISK - Risco
+      "\u26D4",
+      // BLOCK - Bloqueio
+      "\u{1F9EA}"
+      // SANDBOX - Isolamento
+    ]);
+    SYMBOLS_EVOLVE = /* @__PURE__ */ new Set([
+      "\u2301",
+      // EVOLVE BLOCK - Bloco de evolução
+      "\u27F3",
+      // EVOLVE - Evoluir
+      "\u2714",
+      // VERIFY - Verificar
+      "\u2713",
+      // VALID - Válido
+      "\u2716",
+      // INVALID - Inválido
+      "\u{1F4DC}"
+      // LOG - Registro
+    ]);
+    SYMBOLS_LOGIC = /* @__PURE__ */ new Set([
+      "\u039B",
+      // LOGIC - Lógica condicional
+      "\u2297"
+      // PARALLEL BLOCK - Bloco paralelo
+    ]);
+    SYMBOLS = /* @__PURE__ */ new Set([
+      ...SYMBOLS_STATE,
+      ...SYMBOLS_EXEC,
+      ...SYMBOLS_STRUCT,
+      ...SYMBOLS_TIME,
+      ...SYMBOLS_ENERGY,
+      ...SYMBOLS_MEMORY,
+      ...SYMBOLS_UI,
+      ...SYMBOLS_SECURITY,
+      ...SYMBOLS_EVOLVE,
+      ...SYMBOLS_LOGIC
+    ]);
+    SYMBOL_NAMES = {
+      "\u03A3": "STATE",
+      "\u03C3": "SUBSTATE",
+      "\xD8": "VOID",
+      "\u{1F512}": "LOCK",
+      "\u{1F513}": "UNLOCK",
+      "\u0394": "ACTION",
+      "\u0192": "FUNCTION",
+      "\u21C9": "PARALLEL",
+      "\u25B3": "DEPEND",
+      "\u25CF": "CORE",
+      "\u23F3": "DELAY",
+      "\u03A9": "OBJECT",
+      "\u25A0": "OBJECT_ALT",
+      "\u25CB": "CLASS",
+      "\u2B12": "INHERIT",
+      "\u2283": "CONTAINS",
+      "\u2254": "ASSIGN",
+      "\u29C9": "MODULE",
+      "\u26A1": "CAUSE",
+      "\u2726": "CONSEQUENCE",
+      "\u21BB": "LOOP",
+      "\u25CC": "EVENT",
+      "\u21C4": "SYNC",
+      "\u231B": "TIMEOUT",
+      "\u03A8": "ENERGY",
+      "\u23EC": "THROTTLE",
+      "\u23EB": "BOOST",
+      "\u20B5": "COST",
+      "\u{1D4DC}": "MEMORY",
+      "\u267E": "PERSIST",
+      "\u2302": "ROOT",
+      "\u03A6": "FORM",
+      "\u0398": "ANIMATION",
+      "\u2610": "INTERFACE",
+      "\u{1F441}": "VISUAL",
+      "\u2328": "INPUT",
+      "\u{1F9ED}": "POINTER",
+      "\u{1F6E1}": "SECURITY",
+      "\u{1F511}": "KEY",
+      "\u26A0": "RISK",
+      "\u26D4": "BLOCK",
+      "\u{1F9EA}": "SANDBOX",
+      "\u2301": "EVOLVE_BLOCK",
+      "\u27F3": "EVOLVE",
+      "\u2714": "VERIFY",
+      "\u2713": "VALID",
+      "\u2716": "INVALID",
+      "\u{1F4DC}": "LOG",
+      "\u039B": "LOGIC",
+      "\u2297": "PARALLEL_BLOCK"
+    };
+    OPERATORS = /* @__PURE__ */ new Set(["+", "\u2212", "-", "\u2254"]);
+  }
+});
+
+// src/parser/ebnfParser.ts
+function peek(cx) {
+  return cx.tokens[cx.i];
+}
+function next(cx) {
+  return cx.tokens[cx.i++];
+}
+function eat(cx, type, value) {
+  const t = peek(cx);
+  if (!t) throw new Error(`Unexpected EOF, expected ${type}`);
+  if (t.type !== type) throw new Error(`Expected token ${type} but got ${t.type} ('${t.value}') at ${t.pos}`);
+  if (value !== void 0 && t.value !== value) throw new Error(`Expected token value ${value} but got '${t.value}' at ${t.pos}`);
+  return next(cx);
+}
+function skipNewlines(cx) {
+  while (peek(cx) && peek(cx).type === "NEWLINE" /* NEWLINE */) next(cx);
+}
+function parseTokens(tokens, options) {
+  const cx = { tokens, i: 0 };
+  const ast = {
+    raw: tokens.map((t) => t.value).join(" "),
+    // Core collections
+    functions: [],
+    ias: [],
+    nodes: [],
+    modules: [],
+    objects: [],
+    forms: [],
+    animations: [],
+    logic: [],
+    parallels: [],
+    build: null,
+    evolve: null,
+    targets: [],
+    version: null,
+    logs: [],
+    // Extended collections from full alphabet
+    substates: [],
+    classes: [],
+    loops: [],
+    events: [],
+    syncs: [],
+    timeouts: [],
+    delays: [],
+    securities: [],
+    keys: [],
+    sandboxes: [],
+    causes: [],
+    consequences: [],
+    memories: [],
+    persists: [],
+    roots: [],
+    interfaces: [],
+    visuals: [],
+    inputs: [],
+    throttles: [],
+    boosts: [],
+    costs: [],
+    locks: [],
+    unlocks: [],
+    voids: [],
+    inherits: [],
+    contains: [],
+    verifies: [],
+    logNodes: [],
+    database: null,
+    kernel: null,
+    training: null
+  };
+  const onLog = (e) => {
+    const entry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...e };
+    ast.logs.push(entry);
+    if (options?.onLog) options.onLog(entry);
+  };
+  skipNewlines(cx);
+  while (peek(cx) && peek(cx).type !== "EOF" /* EOF */) {
+    const t = peek(cx);
+    if (t.type === "SYMBOL" /* SYMBOL */) {
+      const sym = t.value;
+      next(cx);
+      skipNewlines(cx);
+      while (peek(cx) && peek(cx).type === "NEWLINE" /* NEWLINE */) next(cx);
+      const ident = peek(cx);
+      if (!ident) break;
+      const kw = ident.type === "IDENTIFIER" /* IDENTIFIER */ ? ident.value.toUpperCase() : void 0;
+      if (sym === "\u03A3" && kw === "SYSTEM") {
+        next(cx);
+        skipNewlines(cx);
+        const nameTok = eat(cx, "STRING" /* STRING */);
+        ast.system = nameTok.value;
+        onLog({ level: "info", event: "parse.system", detail: { name: ast.system } });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "TARGET") {
+        next(cx);
+        skipNewlines(cx);
+        const targets = [];
+        while (peek(cx) && peek(cx).type !== "NEWLINE" /* NEWLINE */ && peek(cx).type !== "EOF" /* EOF */) {
+          const v = peek(cx);
+          if (v.type === "IDENTIFIER" /* IDENTIFIER */ || v.type === "STRING" /* STRING */) {
+            targets.push(v.value);
+            next(cx);
+          } else if (v.type === "COMMA" /* COMMA */) {
+            next(cx);
+          } else {
+            break;
+          }
+        }
+        ast.targets = [...ast.targets || [], ...targets];
+        onLog({ level: "info", event: "parse.target", detail: { targets } });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "MODE") {
+        next(cx);
+        skipNewlines(cx);
+        const v = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        ast.mode = v.value;
+        onLog({ level: "info", event: "parse.mode", detail: { mode: ast.mode } });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "UI") {
+        next(cx);
+        skipNewlines(cx);
+        const v = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        ast.ui = v.value;
+        onLog({ level: "info", event: "parse.ui", detail: { ui: ast.ui } });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "MODULE") {
+        next(cx);
+        skipNewlines(cx);
+        const nameTok = eat(cx, "STRING" /* STRING */);
+        const module2 = { type: "module", name: nameTok.value };
+        ast.modules.push(module2);
+        ast.nodes.push(module2);
+        onLog({ level: "info", event: "parse.module", detail: module2 });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "BUILD") {
+        next(cx);
+        skipNewlines(cx);
+        eat(cx, "LBRACE" /* LBRACE */);
+        const targets = [];
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+          const key = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+          eat(cx, "COLON" /* COLON */);
+          const val = peek(cx);
+          if (val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "STRING" /* STRING */) {
+            targets.push(val.value);
+            next(cx);
+          } else {
+            throw new Error("Expected identifier or string for build target");
+          }
+          skipNewlines(cx);
+          if (peek(cx) && peek(cx).type === "COMMA" /* COMMA */) next(cx);
+          skipNewlines(cx);
+        }
+        eat(cx, "RBRACE" /* RBRACE */);
+        const b = { type: "build", targets };
+        ast.build = b;
+        ast.nodes.push(b);
+        onLog({ level: "info", event: "parse.build", detail: b });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "EVOLVE") {
+        next(cx);
+        skipNewlines(cx);
+        const v = peek(cx);
+        if (v && (v.type === "IDENTIFIER" /* IDENTIFIER */ || v.type === "STRING" /* STRING */)) {
+          const ev = { type: "evolve", steps: [next(cx).value] };
+          ast.evolve = ev;
+          onLog({ level: "info", event: "parse.evolve", detail: ev });
+        }
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "DATABASE") {
+        next(cx);
+        skipNewlines(cx);
+        const v = peek(cx);
+        if (v && v.type === "IDENTIFIER" /* IDENTIFIER */) {
+          const mode = next(cx).value;
+          const db = { type: "database", mode };
+          ast.database = db;
+          ast.nodes.push(db);
+          onLog({ level: "info", event: "parse.database", detail: db });
+        }
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "KERNEL") {
+        next(cx);
+        skipNewlines(cx);
+        const hooks = [];
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            const p = peek(cx);
+            if (p.type === "IDENTIFIER" /* IDENTIFIER */) {
+              const hookName = next(cx).value;
+              if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+                hooks.push(hookName + " " + next(cx).value);
+              } else {
+                hooks.push(hookName);
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const kernel = { type: "kernel", hooks };
+        ast.kernel = kernel;
+        ast.nodes.push(kernel);
+        onLog({ level: "info", event: "parse.kernel", detail: kernel });
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "TRAINING") {
+        next(cx);
+        skipNewlines(cx);
+        const v = peek(cx);
+        if (v && (v.type === "IDENTIFIER" /* IDENTIFIER */ || v.type === "STRING" /* STRING */)) {
+          const training = { type: "training", topic: next(cx).value };
+          ast.training = training;
+          ast.nodes.push(training);
+          onLog({ level: "info", event: "parse.training", detail: training });
+        }
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A3" && kw === "LEVEL") {
+        next(cx);
+        skipNewlines(cx);
+        const v = peek(cx);
+        if (v && v.type === "NUMBER" /* NUMBER */) {
+          if (ast.training) {
+            ast.training.level = parseInt(next(cx).value, 10);
+          } else {
+            next(cx);
+          }
+        }
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u0394") {
+        let nameTok = null;
+        if (kw === "FUNCTION") {
+          next(cx);
+          skipNewlines(cx);
+          const tname = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+          nameTok = tname;
+        } else {
+          if (ident.type === "IDENTIFIER" /* IDENTIFIER */) {
+            nameTok = next(cx);
+          }
+        }
+        if (!nameTok) {
+          onLog({ level: "warn", event: "parse.function.missing.name" });
+          skipNewlines(cx);
+          continue;
+        }
+        skipNewlines(cx);
+        let args = [];
+        if (peek(cx) && peek(cx).type === "LPAREN" /* LPAREN */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RPAREN" /* RPAREN */) {
+            const arg = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+            args.push(arg.value);
+            if (peek(cx) && peek(cx).type === "COMMA" /* COMMA */) next(cx);
+            skipNewlines(cx);
+          }
+          eat(cx, "RPAREN" /* RPAREN */);
+        }
+        const steps = [];
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          const bodyTok = peek(cx);
+          if (bodyTok && (bodyTok.type === "IDENTIFIER" /* IDENTIFIER */ || bodyTok.type === "STRING" /* STRING */)) {
+            steps.push({ raw: bodyTok.value });
+            next(cx);
+          }
+          skipNewlines(cx);
+        }
+        onLog({ level: "info", event: "parse.function.start", detail: { name: nameTok.value, args } });
+        const fn2 = { type: "function", name: nameTok.value, args, steps };
+        ast.functions.push(fn2);
+        ast.nodes.push(fn2);
+        onLog({ level: "info", event: "parse.function.end", detail: fn2 });
+        continue;
+      }
+      if (sym === "\u03A8") {
+        if (kw === "IA") {
+          next(cx);
+          skipNewlines(cx);
+          const nameTok = peek(cx);
+          let name = "ia";
+          if (nameTok && (nameTok.type === "STRING" /* STRING */ || nameTok.type === "IDENTIFIER" /* IDENTIFIER */)) {
+            name = next(cx).value;
+          }
+          const body = [];
+          skipNewlines(cx);
+          if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+            next(cx);
+            skipNewlines(cx);
+            while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+              const cap = peek(cx);
+              if (cap.type === "IDENTIFIER" /* IDENTIFIER */ || cap.type === "STRING" /* STRING */) {
+                body.push(cap.value);
+                next(cx);
+              } else {
+                next(cx);
+              }
+              skipNewlines(cx);
+            }
+            if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+          } else {
+            while (peek(cx) && peek(cx).type !== "SYMBOL" /* SYMBOL */ && peek(cx).type !== "EOF" /* EOF */ && peek(cx).type !== "NEWLINE" /* NEWLINE */) {
+              const cap = peek(cx);
+              if (cap.type === "IDENTIFIER" /* IDENTIFIER */ || cap.type === "STRING" /* STRING */) {
+                body.push(cap.value);
+                next(cx);
+              } else break;
+              skipNewlines(cx);
+            }
+          }
+          const ia = { type: "ia", name, body };
+          ast.ias.push(ia);
+          ast.nodes.push(ia);
+          onLog({ level: "info", event: "parse.ia", detail: ia });
+          continue;
+        }
+        skipNewlines(cx);
+        continue;
+      }
+      if (sym === "\u03A9") {
+        skipNewlines(cx);
+        const nameTok = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        const name = nameTok.value;
+        const props = {};
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            const p = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+            skipNewlines(cx);
+            if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+              next(cx);
+              skipNewlines(cx);
+              const val = peek(cx);
+              if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                props[p.value] = val.value;
+                next(cx);
+              } else {
+                props[p.value] = null;
+              }
+            } else {
+              props[p.value] = null;
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const obj = { type: "object", name, props };
+        ast.objects.push(obj);
+        ast.nodes.push(obj);
+        onLog({ level: "info", event: "parse.object", detail: obj });
+        continue;
+      }
+      if (sym === "\u03A6") {
+        skipNewlines(cx);
+        let name = "form";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ && cx.tokens[cx.i + 1] && cx.tokens[cx.i + 1].type !== "LBRACE" /* LBRACE */) {
+          name = next(cx).value;
+        }
+        const props = {};
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+              const key = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+              eat(cx, "COLON" /* COLON */);
+              const val = peek(cx);
+              if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                props[key.value] = val.value;
+                next(cx);
+              } else {
+                props[key.value] = true;
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const form = { type: "form", name, props };
+        ast.forms.push(form);
+        ast.nodes.push(form);
+        onLog({ level: "info", event: "parse.form", detail: form });
+        continue;
+      }
+      if (sym === "\u0398") {
+        skipNewlines(cx);
+        const maybeAnim = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        if (maybeAnim.value.toLowerCase() !== "animation") {
+          onLog({ level: "warn", event: "parse.animation.missing.keyword" });
+          continue;
+        }
+        skipNewlines(cx);
+        const nameTok = peek(cx);
+        let name = "animation";
+        if (nameTok && (nameTok.type === "STRING" /* STRING */ || nameTok.type === "IDENTIFIER" /* IDENTIFIER */)) {
+          name = next(cx).value;
+        }
+        const props = {};
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type !== "SYMBOL" /* SYMBOL */ && peek(cx).type !== "EOF" /* EOF */) {
+          if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+            const key = next(cx).value;
+            if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+              next(cx);
+              const val = peek(cx);
+              if (val && (val.type === "STRING" /* STRING */ || val.type === "NUMBER" /* NUMBER */ || val.type === "IDENTIFIER" /* IDENTIFIER */)) {
+                props[key] = val.value;
+                next(cx);
+              }
+            } else {
+              props[key] = true;
+            }
+          } else {
+            break;
+          }
+          skipNewlines(cx);
+        }
+        const anim = { type: "animation", name, props };
+        ast.animations.push(anim);
+        ast.nodes.push(anim);
+        onLog({ level: "info", event: "parse.animation", detail: anim });
+        continue;
+      }
+      if (sym === "\u039B") {
+        skipNewlines(cx);
+        const ifTok = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        if (ifTok.value.toLowerCase() !== "if") {
+          onLog({ level: "warn", event: "parse.logic.missing.if" });
+          continue;
+        }
+        const leftTok = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+        let leftName = leftTok.value;
+        while (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ && peek(cx).value === ".") {
+          next(cx);
+          const p = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+          leftName += "." + p.value;
+        }
+        const comp = eat(cx, "COMPARATOR" /* COMPARATOR */);
+        const right = peek(cx);
+        if (!right || !(right.type === "STRING" /* STRING */ || right.type === "NUMBER" /* NUMBER */ || right.type === "IDENTIFIER" /* IDENTIFIER */)) throw new Error("Invalid logic right-hand side");
+        next(cx);
+        const rule = `${leftName} ${comp.value} ${right.value}`;
+        const trueFlow = [];
+        const falseFlow = [];
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          const step = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+          trueFlow.push(step.value);
+          skipNewlines(cx);
+        }
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ && peek(cx).value.toLowerCase() === "else") {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+            next(cx);
+            const step = eat(cx, "IDENTIFIER" /* IDENTIFIER */);
+            falseFlow.push(step.value);
+            skipNewlines(cx);
+          }
+        }
+        const logic = { type: "logic", rule, trueFlow, falseFlow };
+        ast.logic.push(logic);
+        ast.nodes.push(logic);
+        onLog({ level: "info", event: "parse.logic", detail: logic });
+        continue;
+      }
+      if (sym === "\u2297") {
+        skipNewlines(cx);
+        const items = [];
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            const parts = [];
+            while (peek(cx) && peek(cx).type !== "NEWLINE" /* NEWLINE */ && peek(cx).type !== "RBRACE" /* RBRACE */) {
+              const p = peek(cx);
+              if (p.type === "IDENTIFIER" /* IDENTIFIER */ || p.type === "STRING" /* STRING */ || p.type === "NUMBER" /* NUMBER */) {
+                parts.push(next(cx).value);
+              } else {
+                next(cx);
+              }
+            }
+            if (parts.length > 0) items.push(parts.join(" "));
+            if (peek(cx) && peek(cx).type === "NEWLINE" /* NEWLINE */) next(cx);
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const par = { type: "parallel", items };
+        ast.parallels.push(par);
+        ast.nodes.push(par);
+        onLog({ level: "info", event: "parse.parallel", detail: par });
+        continue;
+      }
+      if (sym === "\u2301" && kw === "EVOLVE") {
+        next(cx);
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          const steps = [];
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            const p = peek(cx);
+            if (p.type === "IDENTIFIER" /* IDENTIFIER */ || p.type === "STRING" /* STRING */) {
+              steps.push(p.value);
+              next(cx);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+          const ev = { type: "evolve", steps };
+          ast.evolve = ev;
+          ast.nodes.push(ev);
+          onLog({ level: "info", event: "parse.evolve", detail: ev });
+          continue;
+        }
+      }
+      if (sym === "\u03C3") {
+        skipNewlines(cx);
+        let name = "substate";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const props = {};
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+              const key = next(cx).value;
+              if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+                next(cx);
+                const val = peek(cx);
+                if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                  props[key] = next(cx).value;
+                }
+              } else {
+                props[key] = true;
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const substate = { type: "substate", name, props };
+        ast.substates.push(substate);
+        ast.nodes.push(substate);
+        onLog({ level: "info", event: "parse.substate", detail: substate });
+        continue;
+      }
+      if (sym === "\u25CB") {
+        skipNewlines(cx);
+        let name = "class";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        let extendsClass;
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ && peek(cx).value.toLowerCase() === "extends") {
+          next(cx);
+          if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+            extendsClass = next(cx).value;
+          }
+        }
+        const props = {};
+        const methods = [];
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+              const key = next(cx).value;
+              if (peek(cx) && peek(cx).type === "LPAREN" /* LPAREN */) {
+                methods.push(key);
+                next(cx);
+                while (peek(cx) && peek(cx).type !== "RPAREN" /* RPAREN */) next(cx);
+                if (peek(cx)) next(cx);
+              } else if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+                next(cx);
+                const val = peek(cx);
+                if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                  props[key] = next(cx).value;
+                }
+              } else {
+                props[key] = true;
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const classNode = { type: "class", name, extends: extendsClass, props, methods };
+        ast.classes.push(classNode);
+        ast.nodes.push(classNode);
+        onLog({ level: "info", event: "parse.class", detail: classNode });
+        continue;
+      }
+      if (sym === "\u21BB") {
+        skipNewlines(cx);
+        let count;
+        let condition;
+        const body = [];
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          count = parseInt(next(cx).value, 10);
+        } else if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          condition = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              body.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const loop = { type: "loop", count, condition, body };
+        ast.loops.push(loop);
+        ast.nodes.push(loop);
+        onLog({ level: "info", event: "parse.loop", detail: loop });
+        continue;
+      }
+      if (sym === "\u25CC") {
+        skipNewlines(cx);
+        let name = "event";
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          name = next(cx).value;
+        }
+        const handler = [];
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+            handler.push(next(cx).value);
+          }
+          skipNewlines(cx);
+        }
+        const event = { type: "event", name, handler };
+        ast.events.push(event);
+        ast.nodes.push(event);
+        onLog({ level: "info", event: "parse.event", detail: event });
+        continue;
+      }
+      if (sym === "\u21C4") {
+        skipNewlines(cx);
+        const sources = [];
+        while (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          sources.push(next(cx).value);
+          if (peek(cx) && peek(cx).type === "COMMA" /* COMMA */) next(cx);
+          skipNewlines(cx);
+        }
+        const sync = { type: "sync", sources };
+        ast.syncs.push(sync);
+        ast.nodes.push(sync);
+        onLog({ level: "info", event: "parse.sync", detail: sync });
+        continue;
+      }
+      if (sym === "\u231B") {
+        skipNewlines(cx);
+        let duration = 0;
+        let unit = "ms";
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          duration = parseInt(next(cx).value, 10);
+        }
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const u = peek(cx).value.toLowerCase();
+          if (u === "ms" || u === "s" || u === "m") {
+            unit = u;
+            next(cx);
+          }
+        }
+        const timeout = { type: "timeout", duration, unit };
+        ast.timeouts.push(timeout);
+        ast.nodes.push(timeout);
+        onLog({ level: "info", event: "parse.timeout", detail: timeout });
+        continue;
+      }
+      if (sym === "\u23F3") {
+        skipNewlines(cx);
+        let duration = 0;
+        let unit = "ms";
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          duration = parseInt(next(cx).value, 10);
+        }
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const u = peek(cx).value.toLowerCase();
+          if (u === "ms" || u === "s" || u === "m") {
+            unit = u;
+            next(cx);
+          }
+        }
+        const delay = { type: "delay", duration, unit };
+        ast.delays.push(delay);
+        ast.nodes.push(delay);
+        onLog({ level: "info", event: "parse.delay", detail: delay });
+        continue;
+      }
+      if (sym === "\u{1F6E1}") {
+        skipNewlines(cx);
+        let level;
+        const rules = [];
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const lv = peek(cx).value.toLowerCase();
+          if (["low", "medium", "high", "critical"].includes(lv)) {
+            level = lv;
+            next(cx);
+          }
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              rules.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const security = { type: "security", level, rules };
+        ast.securities.push(security);
+        ast.nodes.push(security);
+        onLog({ level: "info", event: "parse.security", detail: security });
+        continue;
+      }
+      if (sym === "\u{1F511}") {
+        skipNewlines(cx);
+        let name = "key";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const permissions = [];
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              permissions.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const key = { type: "key", name, permissions };
+        ast.keys.push(key);
+        ast.nodes.push(key);
+        onLog({ level: "info", event: "parse.key", detail: key });
+        continue;
+      }
+      if (sym === "\u{1F9EA}") {
+        skipNewlines(cx);
+        let name = "sandbox";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const body = [];
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              body.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const sandbox = { type: "sandbox", name, body };
+        ast.sandboxes.push(sandbox);
+        ast.nodes.push(sandbox);
+        onLog({ level: "info", event: "parse.sandbox", detail: sandbox });
+        continue;
+      }
+      if (sym === "\u26A1") {
+        skipNewlines(cx);
+        let trigger = "";
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          trigger = next(cx).value;
+        }
+        const effects = [];
+        skipNewlines(cx);
+        while (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+            effects.push(next(cx).value);
+          }
+          skipNewlines(cx);
+        }
+        const cause = { type: "cause", trigger, effects };
+        ast.causes.push(cause);
+        ast.nodes.push(cause);
+        onLog({ level: "info", event: "parse.cause", detail: cause });
+        continue;
+      }
+      if (sym === "\u2726") {
+        skipNewlines(cx);
+        let source = "";
+        let result = "";
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          source = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+            result = next(cx).value;
+          }
+        }
+        const consequence = { type: "consequence", source, result };
+        ast.consequences.push(consequence);
+        ast.nodes.push(consequence);
+        onLog({ level: "info", event: "parse.consequence", detail: consequence });
+        continue;
+      }
+      if (sym === "\u{1D4DC}") {
+        skipNewlines(cx);
+        let name = "memory";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        let size;
+        let persist = false;
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          size = parseInt(next(cx).value, 10);
+        }
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ && peek(cx).value.toLowerCase() === "persist") {
+          persist = true;
+          next(cx);
+        }
+        const memory = { type: "memory", name, size, persist };
+        ast.memories.push(memory);
+        ast.nodes.push(memory);
+        onLog({ level: "info", event: "parse.memory", detail: memory });
+        continue;
+      }
+      if (sym === "\u267E") {
+        skipNewlines(cx);
+        let target = "";
+        let storage;
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          target = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const s = peek(cx).value.toLowerCase();
+          if (["local", "session", "db", "file"].includes(s)) {
+            storage = s;
+            next(cx);
+          }
+        }
+        const persist = { type: "persist", target, storage };
+        ast.persists.push(persist);
+        ast.nodes.push(persist);
+        onLog({ level: "info", event: "parse.persist", detail: persist });
+        continue;
+      }
+      if (sym === "\u2302") {
+        skipNewlines(cx);
+        let name = "root";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const children = [];
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              children.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const root = { type: "root", name, children };
+        ast.roots.push(root);
+        ast.nodes.push(root);
+        onLog({ level: "info", event: "parse.root", detail: root });
+        continue;
+      }
+      if (sym === "\u2610") {
+        skipNewlines(cx);
+        let name = "interface";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const methods = [];
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+              methods.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const iface = { type: "interface", name, methods };
+        ast.interfaces.push(iface);
+        ast.nodes.push(iface);
+        onLog({ level: "info", event: "parse.interface", detail: iface });
+        continue;
+      }
+      if (sym === "\u{1F441}") {
+        skipNewlines(cx);
+        let name = "visual";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        const props = {};
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+              const key = next(cx).value;
+              if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+                next(cx);
+                const val = peek(cx);
+                if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                  props[key] = next(cx).value;
+                }
+              } else {
+                props[key] = true;
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const visual = { type: "visual", name, props };
+        ast.visuals.push(visual);
+        ast.nodes.push(visual);
+        onLog({ level: "info", event: "parse.visual", detail: visual });
+        continue;
+      }
+      if (sym === "\u2328") {
+        skipNewlines(cx);
+        let name = "input";
+        let inputType = "text";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          name = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const t2 = peek(cx).value.toLowerCase();
+          if (["text", "number", "file", "event"].includes(t2)) {
+            inputType = t2;
+            next(cx);
+          }
+        }
+        const input = { type: "input", name, inputType };
+        ast.inputs.push(input);
+        ast.nodes.push(input);
+        onLog({ level: "info", event: "parse.input", detail: input });
+        continue;
+      }
+      if (sym === "\u23EC") {
+        skipNewlines(cx);
+        let target = "";
+        let limit = 0;
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          target = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          limit = parseInt(next(cx).value, 10);
+        }
+        const throttle = { type: "throttle", target, limit };
+        ast.throttles.push(throttle);
+        ast.nodes.push(throttle);
+        onLog({ level: "info", event: "parse.throttle", detail: throttle });
+        continue;
+      }
+      if (sym === "\u23EB") {
+        skipNewlines(cx);
+        let target = "";
+        let factor;
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          target = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          factor = parseFloat(next(cx).value);
+        }
+        const boost = { type: "boost", target, factor };
+        ast.boosts.push(boost);
+        ast.nodes.push(boost);
+        onLog({ level: "info", event: "parse.boost", detail: boost });
+        continue;
+      }
+      if (sym === "\u20B5") {
+        skipNewlines(cx);
+        let operation = "";
+        let value = 0;
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          operation = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "NUMBER" /* NUMBER */) {
+          value = parseFloat(next(cx).value);
+        }
+        const cost = { type: "cost", operation, value };
+        ast.costs.push(cost);
+        ast.nodes.push(cost);
+        onLog({ level: "info", event: "parse.cost", detail: cost });
+        continue;
+      }
+      if (sym === "\u{1F512}") {
+        skipNewlines(cx);
+        let target = "";
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          target = next(cx).value;
+        }
+        const lock = { type: "lock", target };
+        ast.locks.push(lock);
+        ast.nodes.push(lock);
+        onLog({ level: "info", event: "parse.lock", detail: lock });
+        continue;
+      }
+      if (sym === "\u{1F513}") {
+        skipNewlines(cx);
+        let target = "";
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          target = next(cx).value;
+        }
+        const unlock = { type: "unlock", target };
+        ast.unlocks.push(unlock);
+        ast.nodes.push(unlock);
+        onLog({ level: "info", event: "parse.unlock", detail: unlock });
+        continue;
+      }
+      if (sym === "\xD8") {
+        skipNewlines(cx);
+        let target;
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          target = next(cx).value;
+        }
+        const voidNode = { type: "void", target };
+        ast.voids.push(voidNode);
+        ast.nodes.push(voidNode);
+        onLog({ level: "info", event: "parse.void", detail: voidNode });
+        continue;
+      }
+      if (sym === "\u2B12") {
+        skipNewlines(cx);
+        let child = "";
+        let parent = "";
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          child = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "ARROW" /* ARROW */) {
+          next(cx);
+          if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+            parent = next(cx).value;
+          }
+        }
+        const inherit = { type: "inherit", child, parent };
+        ast.inherits.push(inherit);
+        ast.nodes.push(inherit);
+        onLog({ level: "info", event: "parse.inherit", detail: inherit });
+        continue;
+      }
+      if (sym === "\u2283") {
+        skipNewlines(cx);
+        let container = "";
+        const items = [];
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          container = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              items.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const contains = { type: "contains", container, items };
+        ast.contains.push(contains);
+        ast.nodes.push(contains);
+        onLog({ level: "info", event: "parse.contains", detail: contains });
+        continue;
+      }
+      if (sym === "\u2714") {
+        skipNewlines(cx);
+        let target = "";
+        const rules = [];
+        if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          target = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              rules.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const verify = { type: "verify", target, rules };
+        ast.verifies.push(verify);
+        ast.nodes.push(verify);
+        onLog({ level: "info", event: "parse.verify", detail: verify });
+        continue;
+      }
+      if (sym === "\u{1F4DC}") {
+        skipNewlines(cx);
+        let message = "";
+        let level = "info";
+        if (peek(cx) && (peek(cx).type === "STRING" /* STRING */ || peek(cx).type === "IDENTIFIER" /* IDENTIFIER */)) {
+          message = next(cx).value;
+        }
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "IDENTIFIER" /* IDENTIFIER */) {
+          const lv = peek(cx).value.toLowerCase();
+          if (["debug", "info", "warn", "error"].includes(lv)) {
+            level = lv;
+            next(cx);
+          }
+        }
+        const logNode = { type: "log", message, level };
+        ast.logNodes.push(logNode);
+        ast.nodes.push(logNode);
+        onLog({ level: "info", event: "parse.log", detail: logNode });
+        continue;
+      }
+      if (sym === "\u27F3") {
+        skipNewlines(cx);
+        const steps = [];
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            if (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */) {
+              steps.push(next(cx).value);
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        } else if (peek(cx) && (peek(cx).type === "IDENTIFIER" /* IDENTIFIER */ || peek(cx).type === "STRING" /* STRING */)) {
+          steps.push(next(cx).value);
+        }
+        const ev = { type: "evolve", steps };
+        ast.evolve = ev;
+        ast.nodes.push(ev);
+        onLog({ level: "info", event: "parse.evolve", detail: ev });
+        continue;
+      }
+      if (sym === "\u25A0") {
+        skipNewlines(cx);
+        const nameTok = peek(cx);
+        if (!nameTok || nameTok.type !== "IDENTIFIER" /* IDENTIFIER */) {
+          skipNewlines(cx);
+          continue;
+        }
+        const name = next(cx).value;
+        const props = {};
+        skipNewlines(cx);
+        if (peek(cx) && peek(cx).type === "LBRACE" /* LBRACE */) {
+          next(cx);
+          skipNewlines(cx);
+          while (peek(cx) && peek(cx).type !== "RBRACE" /* RBRACE */) {
+            const p = peek(cx);
+            if (p && p.type === "IDENTIFIER" /* IDENTIFIER */) {
+              const key = next(cx).value;
+              if (peek(cx) && peek(cx).type === "COLON" /* COLON */) {
+                next(cx);
+                const val = peek(cx);
+                if (val && (val.type === "STRING" /* STRING */ || val.type === "IDENTIFIER" /* IDENTIFIER */ || val.type === "NUMBER" /* NUMBER */)) {
+                  props[key] = next(cx).value;
+                } else {
+                  props[key] = null;
+                }
+              } else {
+                props[key] = null;
+              }
+            } else {
+              next(cx);
+            }
+            skipNewlines(cx);
+          }
+          if (peek(cx) && peek(cx).type === "RBRACE" /* RBRACE */) next(cx);
+        }
+        const obj = { type: "object", name, props };
+        ast.objects.push(obj);
+        ast.nodes.push(obj);
+        onLog({ level: "info", event: "parse.object", detail: obj });
+        continue;
+      }
+      skipNewlines(cx);
+      continue;
+    }
+    if (t.type === "SYMBOL" /* SYMBOL */ && t.value === "\u0394") {
+      next(cx);
+    }
+    if (t.type === "IDENTIFIER" /* IDENTIFIER */ && t.value.toLowerCase() === "\u0394") {
+      next(cx);
+      continue;
+    }
+    if (t.type === "IDENTIFIER" /* IDENTIFIER */) {
+      const val = t.value.toLowerCase();
+      next(cx);
+      skipNewlines(cx);
+      continue;
+    }
+    next(cx);
+    skipNewlines(cx);
+  }
+  return ast;
+}
+function parseFromCode(code, options) {
+  const tokens = tokenize(code);
+  return parseTokens(tokens, options);
+}
+var init_ebnfParser = __esm({
+  "src/parser/ebnfParser.ts"() {
+    "use strict";
+    init_tokenize();
+  }
+});
+
+// src/parser.ts
+var parser_exports = {};
+__export(parser_exports, {
+  parse: () => parse,
+  writeWithRetry: () => writeWithRetry
+});
+async function writeWithRetry(entry, filePath, attempts = 3, delay = 1e3, onLog) {
+  const fsPromises = await import("fs/promises");
+  let attempt = 0;
+  const tryWrite = async () => {
+    attempt++;
+    try {
+      await fsPromises.appendFile(filePath, JSON.stringify(entry) + "\n", { encoding: "utf8" });
+      if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "logfile.write.success", detail: { file: filePath } });
+      return;
+    } catch (err) {
+      const errEntry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "logfile.write.retry", detail: { attempt, error: String(err) } };
+      if (onLog) onLog(errEntry);
+      if (attempt < attempts) {
+        setTimeout(() => {
+          tryWrite().catch(() => {
+          });
+        }, delay);
+      } else {
+        const fatal = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "error", event: "logfile.write.fatal", detail: { attempt, error: String(err) } };
+        if (onLog) onLog(fatal);
+      }
+    }
+  };
+  tryWrite().catch(() => {
+  });
+}
+function parse(code, options) {
+  const ast = parseFromCode(code, options);
+  ast.logs = ast.logs || [];
+  return ast;
+}
+var init_parser = __esm({
+  "src/parser.ts"() {
+    "use strict";
+    init_ebnfParser();
+  }
+});
+
+// src/transpile.ts
+var transpile_exports = {};
+__export(transpile_exports, {
+  hasWASMTarget: () => hasWASMTarget,
+  transpileToDTS: () => transpileToDTS,
+  transpileToJS: () => transpileToJS,
+  transpileToWAT: () => transpileToWAT
+});
+function transpileToJS(ast, options) {
+  const parts = [];
+  const format = options?.moduleFormat || "esm";
+  const isESM = format === "esm";
+  parts.push("// Generated by enyosx-ai (transpiler)");
+  if (ast.system) {
+    parts.push(isESM ? `export const SYSTEM = ${JSON.stringify(ast.system)};` : `const SYSTEM = ${JSON.stringify(ast.system)};
+module.exports.SYSTEM = SYSTEM;`);
+  }
+  if (ast.mode) {
+    parts.push(isESM ? `export const MODE = ${JSON.stringify(ast.mode)};` : `const MODE = ${JSON.stringify(ast.mode)};
+module.exports.MODE = MODE;`);
+  }
+  if (ast.ui) {
+    parts.push(isESM ? `export const UI = ${JSON.stringify(ast.ui)};` : `const UI = ${JSON.stringify(ast.ui)};
+module.exports.UI = UI;`);
+  }
+  const functionNames = [];
+  if (ast.functions && ast.functions.length) {
+    for (const fn2 of ast.functions) {
+      const args = (fn2.args || []).join(", ");
+      const bodyLines = (fn2.steps || []).map((s) => `  // ${s.raw}`);
+      functionNames.push(fn2.name);
+      if (isESM) {
+        const fnCode = `export function ${fn2.name}(${args}) {
+${bodyLines.join("\n")}
+}`;
+        parts.push(fnCode);
+      } else {
+        const fnCode = `function ${fn2.name}(${args}) {
+${bodyLines.join("\n")}
+}
+module.exports.${fn2.name} = ${fn2.name};`;
+        parts.push(fnCode);
+      }
+    }
+  }
+  const iaNames = [];
+  if (ast.ias && ast.ias.length) {
+    for (const ia of ast.ias) {
+      const body = ia.body.map((b) => `  // ${b}`).join("\n");
+      const name = ia.name.replace(/[^a-zA-Z0-9_]/g, "_");
+      const constName = `IA_${name}`;
+      iaNames.push(constName);
+      if (isESM) {
+        const code = `export const ${constName} = { name: ${JSON.stringify(ia.name)}, run: () => {
+${body}
+} };`;
+        parts.push(code);
+      } else {
+        const code = `const ${constName} = { name: ${JSON.stringify(ia.name)}, run: () => {
+${body}
+} };
+module.exports.${constName} = ${constName};`;
+        parts.push(code);
+      }
+    }
+  }
+  const objectNames = [];
+  if (ast.objects && ast.objects.length) {
+    for (const o of ast.objects) {
+      objectNames.push(o.name);
+      parts.push(isESM ? `export const ${o.name} = ${JSON.stringify(o.props, null, 2)};` : `const ${o.name} = ${JSON.stringify(o.props, null, 2)};
+module.exports.${o.name} = ${o.name};`);
+    }
+  }
+  const formNames = [];
+  if (ast.forms && ast.forms.length) {
+    for (const f of ast.forms) {
+      const constName = `FORM_${f.name}`;
+      formNames.push(constName);
+      parts.push(isESM ? `export const ${constName} = ${JSON.stringify(f.props, null, 2)};` : `const ${constName} = ${JSON.stringify(f.props, null, 2)};
+module.exports.${constName} = ${constName};`);
+    }
+  }
+  const animNames = [];
+  if (ast.animations && ast.animations.length) {
+    for (const a of ast.animations) {
+      const constName = `ANIMATION_${a.name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+      animNames.push(constName);
+      parts.push(isESM ? `export const ${constName} = ${JSON.stringify(a.props, null, 2)};` : `const ${constName} = ${JSON.stringify(a.props, null, 2)};
+module.exports.${constName} = ${constName};`);
+    }
+  }
+  if (ast.build) {
+    parts.push(isESM ? `export const BUILD_TARGETS = ${JSON.stringify(ast.build.targets || [])};` : `const BUILD_TARGETS = ${JSON.stringify(ast.build.targets || [])};
+module.exports.BUILD_TARGETS = BUILD_TARGETS;`);
+  }
+  if (ast.evolve) {
+    parts.push(isESM ? `export const EVOLVE_STEPS = ${JSON.stringify(ast.evolve.steps || [])};` : `const EVOLVE_STEPS = ${JSON.stringify(ast.evolve.steps || [])};
+module.exports.EVOLVE_STEPS = EVOLVE_STEPS;`);
+  }
+  if (ast.database) {
+    parts.push(isESM ? `export const DATABASE = ${JSON.stringify(ast.database)};` : `const DATABASE = ${JSON.stringify(ast.database)};
+module.exports.DATABASE = DATABASE;`);
+  }
+  if (ast.kernel) {
+    parts.push(isESM ? `export const KERNEL = ${JSON.stringify(ast.kernel)};` : `const KERNEL = ${JSON.stringify(ast.kernel)};
+module.exports.KERNEL = KERNEL;`);
+  }
+  if (ast.training) {
+    parts.push(isESM ? `export const TRAINING = ${JSON.stringify(ast.training)};` : `const TRAINING = ${JSON.stringify(ast.training)};
+module.exports.TRAINING = TRAINING;`);
+  }
+  if (ast.substates && ast.substates.length) {
+    parts.push(isESM ? `export const SUBSTATES = ${JSON.stringify(ast.substates, null, 2)};` : `const SUBSTATES = ${JSON.stringify(ast.substates, null, 2)};
+module.exports.SUBSTATES = SUBSTATES;`);
+  }
+  if (ast.classes && ast.classes.length) {
+    for (const c of ast.classes) {
+      const className = c.name.replace(/[^a-zA-Z0-9_]/g, "_");
+      parts.push(isESM ? `export class ${className} {
+  constructor() {
+    Object.assign(this, ${JSON.stringify(c.props)});
+  }
+${(c.methods || []).map((m) => `  ${m}() {}`).join("\n")}
+}` : `class ${className} {
+  constructor() {
+    Object.assign(this, ${JSON.stringify(c.props)});
+  }
+${(c.methods || []).map((m) => `  ${m}() {}`).join("\n")}
+}
+module.exports.${className} = ${className};`);
+    }
+  }
+  if (ast.loops && ast.loops.length) {
+    parts.push(isESM ? `export const LOOPS = ${JSON.stringify(ast.loops, null, 2)};` : `const LOOPS = ${JSON.stringify(ast.loops, null, 2)};
+module.exports.LOOPS = LOOPS;`);
+  }
+  if (ast.events && ast.events.length) {
+    for (const e of ast.events) {
+      const eventName = `EVENT_${e.name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+      parts.push(isESM ? `export const ${eventName} = { name: ${JSON.stringify(e.name)}, handler: ${JSON.stringify(e.handler || [])} };` : `const ${eventName} = { name: ${JSON.stringify(e.name)}, handler: ${JSON.stringify(e.handler || [])} };
+module.exports.${eventName} = ${eventName};`);
+    }
+  }
+  if (ast.syncs && ast.syncs.length) {
+    parts.push(isESM ? `export const SYNCS = ${JSON.stringify(ast.syncs, null, 2)};` : `const SYNCS = ${JSON.stringify(ast.syncs, null, 2)};
+module.exports.SYNCS = SYNCS;`);
+  }
+  if (ast.timeouts && ast.timeouts.length) {
+    parts.push(isESM ? `export const TIMEOUTS = ${JSON.stringify(ast.timeouts, null, 2)};` : `const TIMEOUTS = ${JSON.stringify(ast.timeouts, null, 2)};
+module.exports.TIMEOUTS = TIMEOUTS;`);
+  }
+  if (ast.delays && ast.delays.length) {
+    parts.push(isESM ? `export const DELAYS = ${JSON.stringify(ast.delays, null, 2)};` : `const DELAYS = ${JSON.stringify(ast.delays, null, 2)};
+module.exports.DELAYS = DELAYS;`);
+  }
+  if (ast.securities && ast.securities.length) {
+    parts.push(isESM ? `export const SECURITY_RULES = ${JSON.stringify(ast.securities, null, 2)};` : `const SECURITY_RULES = ${JSON.stringify(ast.securities, null, 2)};
+module.exports.SECURITY_RULES = SECURITY_RULES;`);
+  }
+  if (ast.keys && ast.keys.length) {
+    parts.push(isESM ? `export const KEYS = ${JSON.stringify(ast.keys, null, 2)};` : `const KEYS = ${JSON.stringify(ast.keys, null, 2)};
+module.exports.KEYS = KEYS;`);
+  }
+  if (ast.sandboxes && ast.sandboxes.length) {
+    parts.push(isESM ? `export const SANDBOXES = ${JSON.stringify(ast.sandboxes, null, 2)};` : `const SANDBOXES = ${JSON.stringify(ast.sandboxes, null, 2)};
+module.exports.SANDBOXES = SANDBOXES;`);
+  }
+  if (ast.causes && ast.causes.length) {
+    parts.push(isESM ? `export const CAUSES = ${JSON.stringify(ast.causes, null, 2)};` : `const CAUSES = ${JSON.stringify(ast.causes, null, 2)};
+module.exports.CAUSES = CAUSES;`);
+  }
+  if (ast.consequences && ast.consequences.length) {
+    parts.push(isESM ? `export const CONSEQUENCES = ${JSON.stringify(ast.consequences, null, 2)};` : `const CONSEQUENCES = ${JSON.stringify(ast.consequences, null, 2)};
+module.exports.CONSEQUENCES = CONSEQUENCES;`);
+  }
+  if (ast.memories && ast.memories.length) {
+    parts.push(isESM ? `export const MEMORIES = ${JSON.stringify(ast.memories, null, 2)};` : `const MEMORIES = ${JSON.stringify(ast.memories, null, 2)};
+module.exports.MEMORIES = MEMORIES;`);
+  }
+  if (ast.persists && ast.persists.length) {
+    parts.push(isESM ? `export const PERSISTS = ${JSON.stringify(ast.persists, null, 2)};` : `const PERSISTS = ${JSON.stringify(ast.persists, null, 2)};
+module.exports.PERSISTS = PERSISTS;`);
+  }
+  if (ast.interfaces && ast.interfaces.length) {
+    parts.push(isESM ? `export const INTERFACES = ${JSON.stringify(ast.interfaces, null, 2)};` : `const INTERFACES = ${JSON.stringify(ast.interfaces, null, 2)};
+module.exports.INTERFACES = INTERFACES;`);
+  }
+  if (ast.visuals && ast.visuals.length) {
+    parts.push(isESM ? `export const VISUALS = ${JSON.stringify(ast.visuals, null, 2)};` : `const VISUALS = ${JSON.stringify(ast.visuals, null, 2)};
+module.exports.VISUALS = VISUALS;`);
+  }
+  if (ast.inputs && ast.inputs.length) {
+    parts.push(isESM ? `export const INPUTS = ${JSON.stringify(ast.inputs, null, 2)};` : `const INPUTS = ${JSON.stringify(ast.inputs, null, 2)};
+module.exports.INPUTS = INPUTS;`);
+  }
+  if (ast.throttles && ast.throttles.length) {
+    parts.push(isESM ? `export const THROTTLES = ${JSON.stringify(ast.throttles, null, 2)};` : `const THROTTLES = ${JSON.stringify(ast.throttles, null, 2)};
+module.exports.THROTTLES = THROTTLES;`);
+  }
+  if (ast.boosts && ast.boosts.length) {
+    parts.push(isESM ? `export const BOOSTS = ${JSON.stringify(ast.boosts, null, 2)};` : `const BOOSTS = ${JSON.stringify(ast.boosts, null, 2)};
+module.exports.BOOSTS = BOOSTS;`);
+  }
+  if (ast.costs && ast.costs.length) {
+    parts.push(isESM ? `export const COSTS = ${JSON.stringify(ast.costs, null, 2)};` : `const COSTS = ${JSON.stringify(ast.costs, null, 2)};
+module.exports.COSTS = COSTS;`);
+  }
+  if (ast.locks && ast.locks.length) {
+    parts.push(isESM ? `export const LOCKS = ${JSON.stringify(ast.locks, null, 2)};` : `const LOCKS = ${JSON.stringify(ast.locks, null, 2)};
+module.exports.LOCKS = LOCKS;`);
+  }
+  if (ast.unlocks && ast.unlocks.length) {
+    parts.push(isESM ? `export const UNLOCKS = ${JSON.stringify(ast.unlocks, null, 2)};` : `const UNLOCKS = ${JSON.stringify(ast.unlocks, null, 2)};
+module.exports.UNLOCKS = UNLOCKS;`);
+  }
+  if (ast.voids && ast.voids.length) {
+    parts.push(isESM ? `export const VOIDS = ${JSON.stringify(ast.voids, null, 2)};` : `const VOIDS = ${JSON.stringify(ast.voids, null, 2)};
+module.exports.VOIDS = VOIDS;`);
+  }
+  if (ast.inherits && ast.inherits.length) {
+    parts.push(isESM ? `export const INHERITS = ${JSON.stringify(ast.inherits, null, 2)};` : `const INHERITS = ${JSON.stringify(ast.inherits, null, 2)};
+module.exports.INHERITS = INHERITS;`);
+  }
+  if (ast.contains && ast.contains.length) {
+    parts.push(isESM ? `export const CONTAINS = ${JSON.stringify(ast.contains, null, 2)};` : `const CONTAINS = ${JSON.stringify(ast.contains, null, 2)};
+module.exports.CONTAINS = CONTAINS;`);
+  }
+  if (ast.verifies && ast.verifies.length) {
+    parts.push(isESM ? `export const VERIFIES = ${JSON.stringify(ast.verifies, null, 2)};` : `const VERIFIES = ${JSON.stringify(ast.verifies, null, 2)};
+module.exports.VERIFIES = VERIFIES;`);
+  }
+  if (ast.logNodes && ast.logNodes.length) {
+    parts.push(isESM ? `export const LOG_NODES = ${JSON.stringify(ast.logNodes, null, 2)};` : `const LOG_NODES = ${JSON.stringify(ast.logNodes, null, 2)};
+module.exports.LOG_NODES = LOG_NODES;`);
+  }
+  if (isESM) {
+    parts.push("\nexport default { SYSTEM, MODE, UI };");
+  } else {
+    parts.push("\nmodule.exports.default = { SYSTEM, MODE, UI };");
+  }
+  return parts.join("\n\n");
+}
+function transpileToDTS(ast) {
+  const lines = [];
+  lines.push("// Type declarations generated by enyosx-ai");
+  lines.push("");
+  if (ast.system) {
+    lines.push(`export declare const SYSTEM: string;`);
+  }
+  if (ast.mode) {
+    lines.push(`export declare const MODE: string;`);
+  }
+  if (ast.ui) {
+    lines.push(`export declare const UI: string;`);
+  }
+  if (ast.functions && ast.functions.length) {
+    for (const fn2 of ast.functions) {
+      const args = (fn2.args || []).map((a) => `${a}: any`).join(", ");
+      lines.push(`export declare function ${fn2.name}(${args}): void;`);
+    }
+  }
+  if (ast.ias && ast.ias.length) {
+    for (const ia of ast.ias) {
+      const name = ia.name.replace(/[^a-zA-Z0-9_]/g, "_");
+      lines.push(`export declare const IA_${name}: { name: string; run: () => void };`);
+    }
+  }
+  if (ast.objects && ast.objects.length) {
+    for (const o of ast.objects) {
+      const propTypes = Object.keys(o.props).map((k) => `${k}: string | null`).join("; ");
+      lines.push(`export declare const ${o.name}: { ${propTypes} };`);
+    }
+  }
+  if (ast.forms && ast.forms.length) {
+    for (const f of ast.forms) {
+      lines.push(`export declare const FORM_${f.name}: Record<string, any>;`);
+    }
+  }
+  if (ast.animations && ast.animations.length) {
+    for (const a of ast.animations) {
+      const constName = `ANIMATION_${a.name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+      lines.push(`export declare const ${constName}: Record<string, any>;`);
+    }
+  }
+  if (ast.build) {
+    lines.push(`export declare const BUILD_TARGETS: string[];`);
+  }
+  if (ast.evolve) {
+    lines.push(`export declare const EVOLVE_STEPS: string[];`);
+  }
+  lines.push("");
+  lines.push("declare const _default: { SYSTEM: string; MODE: string; UI: string };");
+  lines.push("export default _default;");
+  return lines.join("\n");
+}
+function transpileToWAT(ast) {
+  const lines = [];
+  lines.push(";; WebAssembly Text Format generated by enyosx-ai");
+  lines.push(";; This is a stub for future WASM compilation");
+  lines.push("");
+  lines.push("(module");
+  lines.push(`  ;; System: ${ast.system || "unnamed"}`);
+  lines.push(`  ;; Mode: ${ast.mode || "default"}`);
+  lines.push("");
+  lines.push("  ;; Memory declaration");
+  lines.push('  (memory (export "memory") 1)');
+  lines.push("");
+  if (ast.system) {
+    const bytes = Array.from(new TextEncoder().encode(ast.system)).join(" ");
+    lines.push(`  ;; System name data`);
+    lines.push(`  (data (i32.const 0) "${ast.system}")`);
+    lines.push("");
+  }
+  if (ast.functions && ast.functions.length) {
+    lines.push("  ;; Function stubs");
+    for (const fn2 of ast.functions) {
+      const params = (fn2.args || []).map((_, i) => `(param $arg${i} i32)`).join(" ");
+      lines.push(`  (func (export "${fn2.name}") ${params} (result i32)`);
+      lines.push(`    ;; Steps: ${(fn2.steps || []).map((s) => s.raw).join(" -> ")}`);
+      lines.push(`    i32.const 0  ;; placeholder return`);
+      lines.push(`  )`);
+      lines.push("");
+    }
+  }
+  if (ast.ias && ast.ias.length) {
+    lines.push("  ;; IA stubs (table references for future indirect calls)");
+    for (const ia of ast.ias) {
+      const name = ia.name.replace(/[^a-zA-Z0-9_]/g, "_");
+      lines.push(`  ;; IA: ${ia.name}`);
+      lines.push(`  (func (export "ia_${name}") (result i32)`);
+      lines.push(`    ;; Capabilities: ${ia.body.join(", ")}`);
+      lines.push(`    i32.const 1  ;; stub: IA ready`);
+      lines.push(`  )`);
+      lines.push("");
+    }
+  }
+  lines.push("  ;; Main entry point");
+  lines.push('  (func (export "_start")');
+  lines.push("    ;; Initialize system");
+  lines.push("    nop");
+  lines.push("  )");
+  lines.push("");
+  if (ast.build && ast.build.targets) {
+    lines.push(`  ;; Build targets: ${ast.build.targets.join(", ")}`);
+  }
+  lines.push(")");
+  lines.push("");
+  lines.push(";; To compile this WAT to WASM:");
+  lines.push(";; wat2wasm output.wat -o output.wasm");
+  lines.push(";; Or use wasm-pack for Rust-based compilation");
+  return lines.join("\n");
+}
+function hasWASMTarget(ast) {
+  if (!ast.build || !ast.build.targets) return false;
+  return ast.build.targets.some(
+    (t) => t.toLowerCase() === "wasm" || t.toLowerCase() === "webassembly" || t.toLowerCase() === "wat"
+  );
+}
+var init_transpile = __esm({
+  "src/transpile.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ALPHABET: () => ALPHABET,
+  EVOLVE: () => EVOLVE,
+  FALSE: () => FALSE,
+  FALSE_VAL: () => FALSE_VAL,
+  FUNCTION: () => FUNCTION,
+  IAManager: () => IAManager,
+  INTERFACE: () => INTERFACE,
+  LocalIA: () => LocalIA,
+  NAME: () => NAME,
+  NIL: () => NIL,
+  OBJECT: () => OBJECT,
+  RemoteIA: () => RemoteIA,
+  SHIELD: () => SHIELD,
+  STATE: () => STATE,
+  SUBSTATE: () => SUBSTATE,
+  SYMBOLS: () => SYMBOLS2,
+  SYMBOL_NAMES: () => SYMBOL_NAMES,
+  TRANSPILE_MAP: () => TRANSPILE_MAP,
+  TRUE: () => TRUE,
+  TRUE_VAL: () => TRUE_VAL,
+  TokenType: () => TokenType,
+  VERSION: () => VERSION,
+  VOID: () => VOID,
+  VOID_VAL: () => VOID_VAL,
+  applyEvolve: () => applyEvolve,
+  asyncFn: () => asyncFn,
+  compile: () => compile,
+  component: () => component,
+  createBoost: () => createBoost,
+  createClass: () => createClass,
+  createEvent: () => createEvent,
+  createEvolve: () => createEvolve,
+  createFunction: () => createFunction,
+  createInput: () => createInput,
+  createKey: () => createKey,
+  createLoop: () => createLoop,
+  createMemory: () => createMemory,
+  createObject: () => createObject,
+  createPersist: () => createPersist,
+  createSecurity: () => createSecurity,
+  createSystem: () => createSystem,
+  createThrottle: () => createThrottle,
+  createVisual: () => createVisual,
+  defaultIAManager: () => defaultIAManager,
+  effect: () => effect,
+  error: () => error,
+  filter: () => filter,
+  find: () => find,
+  fn: () => fn,
+  generateENY: () => generateENY,
+  get: () => get,
+  getEnergy: () => getEnergy,
+  getEvolve: () => getEvolve,
+  getFunctions: () => getFunctions,
+  getInterface: () => getInterface,
+  getMemory: () => getMemory,
+  getSecurity: () => getSecurity,
+  getState: () => getState,
+  getStructures: () => getStructures,
+  getTemporals: () => getTemporals,
+  hasWASMTarget: () => hasWASMTarget,
+  isValidENY: () => isValidENY,
+  log: () => log,
+  map: () => map,
+  navigate: () => navigate,
+  parse: () => parse,
+  post: () => post,
+  processIA: () => processIA,
+  quickSystem: () => quickSystem,
+  reduce: () => reduce,
+  runENY: () => runENY,
+  shape: () => shape,
+  state: () => state,
+  storageGet: () => storageGet,
+  storageSet: () => storageSet,
+  toSymbolic: () => toSymbolic,
+  tokenize: () => tokenize,
+  transpileSymbols: () => transpileSymbols,
+  transpileToDTS: () => transpileToDTS,
+  transpileToJS: () => transpileToJS,
+  transpileToWAT: () => transpileToWAT,
+  validate: () => validate,
+  validateSemantic: () => validateSemantic,
+  validateSemanticFull: () => validateSemanticFull
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/runENY.ts
+init_parser();
+init_parser();
+
+// src/semantic/validate.ts
+function validateSemantic(ast, options) {
+  const result = validateSemanticFull(ast, options);
+  return result.errors;
+}
+function validateSemanticFull(ast, options) {
+  const errors = [];
+  const warnings = [];
+  const pillars = {
+    state: false,
+    action: false,
+    form: false,
+    time: false,
+    energy: false,
+    memory: false,
+    interface: false,
+    security: false,
+    evolve: false
+  };
+  const onLog = (e) => {
+    const entry = { timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...e };
+    if (options?.onLog) options.onLog(entry);
+  };
+  ast.functions = ast.functions || [];
+  ast.modules = ast.modules || [];
+  ast.objects = ast.objects || [];
+  ast.events = ast.events || [];
+  ast.securities = ast.securities || [];
+  ast.memories = ast.memories || [];
+  ast.interfaces = ast.interfaces || [];
+  if (ast.system) {
+    pillars.state = true;
+  } else {
+    warnings.push("No \u03A3 SYSTEM declared - consider adding a system name");
+  }
+  if (ast.substates?.length) {
+    for (const sub of ast.substates) {
+      if (sub.parent && !ast.substates.some((s) => s.name === sub.parent)) {
+        warnings.push(`Substate '${sub.name}' references unknown parent '${sub.parent}'`);
+      }
+    }
+  }
+  if (ast.functions.length > 0) {
+    pillars.action = true;
+  }
+  const fnMap = /* @__PURE__ */ new Map();
+  for (const fn2 of ast.functions) {
+    fnMap.set(fn2.name, (fnMap.get(fn2.name) || 0) + 1);
+  }
+  for (const [name, count] of fnMap.entries()) {
+    if (count > 1) {
+      const msg = `Duplicate function name: ${name}`;
+      errors.push(msg);
+      onLog({ level: "error", event: "parse.semantic.error", detail: { error: msg } });
+    }
+  }
+  const knownFns = new Set(ast.functions.map((f) => f.name));
+  for (const fn2 of ast.functions) {
+    for (const step of fn2.steps || []) {
+      const token = step.raw.trim();
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(token) && !knownFns.has(token)) {
+        const msg = `Undefined function reference in '${fn2.name}': '${token}'`;
+        errors.push(msg);
+        onLog({ level: "warn", event: "parse.semantic.error", detail: { error: msg } });
+      }
+    }
+  }
+  if (ast.objects?.length || ast.classes?.length) {
+    pillars.form = true;
+  }
+  if (ast.classes?.length) {
+    const classNames = new Set(ast.classes.map((c) => c.name));
+    for (const cls of ast.classes) {
+      if (cls.extends && !classNames.has(cls.extends)) {
+        warnings.push(`Class '${cls.name}' extends unknown class '${cls.extends}'`);
+      }
+    }
+  }
+  if (ast.inherits?.length) {
+    const allNames = /* @__PURE__ */ new Set([
+      ...ast.classes?.map((c) => c.name) || [],
+      ...ast.objects?.map((o) => o.name) || []
+    ]);
+    for (const inh of ast.inherits) {
+      if (!allNames.has(inh.parent)) {
+        warnings.push(`Inherit: '${inh.child}' extends unknown '${inh.parent}'`);
+      }
+    }
+  }
+  if (ast.events?.length || ast.causes?.length || ast.loops?.length) {
+    pillars.time = true;
+  }
+  if (ast.events?.length) {
+    for (const evt of ast.events) {
+      for (const handler of evt.handler || []) {
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(handler) && !knownFns.has(handler)) {
+          warnings.push(`Event '${evt.name}' handler '${handler}' is not a known function`);
+        }
+      }
+    }
+  }
+  if (ast.throttles?.length || ast.boosts?.length || ast.costs?.length) {
+    pillars.energy = true;
+  }
+  if (ast.throttles?.length) {
+    for (const t of ast.throttles) {
+      if (t.limit <= 0) {
+        errors.push(`Throttle '${t.target}' has invalid limit: ${t.limit}`);
+      }
+    }
+  }
+  if (ast.memories?.length || ast.persists?.length || ast.database) {
+    pillars.memory = true;
+  }
+  if (ast.forms?.length || ast.inputs?.length || ast.visuals?.length || ast.interfaces?.length) {
+    pillars.interface = true;
+  }
+  if (ast.securities?.length || ast.keys?.length || ast.sandboxes?.length) {
+    pillars.security = true;
+  }
+  const validSecurityLevels = ["low", "medium", "high", "critical"];
+  if (ast.securities?.length) {
+    for (const sec of ast.securities) {
+      if (sec.level && !validSecurityLevels.includes(sec.level.toLowerCase())) {
+        warnings.push(`Security rule has unknown level '${sec.level}' (use: low, medium, high, critical)`);
+      }
+    }
+  }
+  if (ast.evolve?.steps?.length) {
+    pillars.evolve = true;
+  }
+  const activePillars = Object.values(pillars).filter(Boolean).length;
+  const score = Math.round(activePillars / 9 * 100);
+  ast.errors = errors;
+  if (errors.length > 0) console.debug("[semantic] errors", errors);
+  return { errors, warnings, pillars, score };
+}
+
+// src/evolve/stub.ts
+function applyEvolve(ast, options) {
+  if (!ast.evolve || !ast.evolve.steps || ast.evolve.steps.length === 0) {
+    return { changed: false, appliedSteps: [], skippedSteps: [] };
+  }
+  const onLog = options?.onLog;
+  const steps = ast.evolve.steps;
+  let changed = false;
+  const appliedSteps = [];
+  const skippedSteps = [];
+  for (const step of steps) {
+    const parts = step.trim().split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+    let applied = false;
+    switch (command) {
+      case "rename": {
+        if (parts.length >= 3) {
+          const [, oldName, newName] = parts;
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === oldName) {
+              fn2.name = newName;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.rename", detail: { from: oldName, to: newName } });
+            }
+          }
+        }
+        break;
+      }
+      case "optimize": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target || target === "*") {
+              fn2.optimized = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.optimize", detail: { target: fn2.name } });
+            }
+          }
+        }
+        break;
+      }
+      case "inline": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.inline = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.inline", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "memoize": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.memoize = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.memoize", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "parallelize": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.parallel = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.parallelize", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "deprecate": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.deprecated = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "evolve.deprecate", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "secure": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.secure = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.secure", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "cache": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const obj of ast.objects || []) {
+            if (obj.name === target) {
+              obj.cached = true;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.cache", detail: { target } });
+            }
+          }
+        }
+        break;
+      }
+      case "throttle": {
+        if (parts.length >= 3) {
+          const target = parts[1];
+          const limit = parseInt(parts[2], 10);
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target) {
+              fn2.throttle = limit;
+              applied = true;
+              if (onLog) onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.throttle", detail: { target, limit } });
+            }
+          }
+        }
+        break;
+      }
+      case "observe": {
+        if (parts.length >= 2) {
+          const target = parts[1];
+          for (const fn2 of ast.functions || []) {
+            if (fn2.name === target || target === "*") {
+              fn2.observable = true;
+              applied = true;
+            }
+          }
+          for (const obj of ast.objects || []) {
+            if (obj.name === target || target === "*") {
+              obj.observable = true;
+              applied = true;
+            }
+          }
+          if (applied && onLog) {
+            onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.observe", detail: { target } });
+          }
+        }
+        break;
+      }
+      default:
+        if (step.includes("otimizar") || step.includes("optimize")) {
+          for (const fn2 of ast.functions || []) {
+            fn2.optimized = true;
+          }
+          applied = true;
+        } else if (step.includes("adaptar") || step.includes("adapt")) {
+          ast.adaptive = true;
+          applied = true;
+        }
+        break;
+    }
+    if (applied) {
+      changed = true;
+      appliedSteps.push(step);
+    } else {
+      skippedSteps.push(step);
+    }
+  }
+  if (changed && onLog) {
+    onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.summary", detail: { appliedSteps, skippedSteps } });
+  }
+  return { changed, appliedSteps, skippedSteps };
+}
+
+// src/runENY.ts
+function runENY(code, options) {
+  const hasSystem = /Σ\s+SYSTEM/i.test(code);
+  if (!hasSystem) {
+    if (options?.onLog) {
+      options.onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "runENY.no-system", detail: { length: code.length } });
+    }
+    if (options?.logFile) {
+      const attempts = options?.logRetryAttempts ?? 3;
+      const delay = options?.logRetryDelayMs ?? 1e3;
+      writeWithRetry({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "runENY.no-system", detail: { length: code.length } }, options.logFile, attempts, delay, options?.onLog);
+    }
+    return { raw: code, isEny: false, logs: [] };
+  }
+  const userOnLog = options?.onLog;
+  let wrappedOnLog = userOnLog;
+  if (options?.logFile) {
+    const attempts = options?.logRetryAttempts ?? 3;
+    const delay = options?.logRetryDelayMs ?? 1e3;
+    wrappedOnLog = (e) => {
+      if (userOnLog) userOnLog(e);
+      writeWithRetry(e, options.logFile, attempts, delay, userOnLog);
+    };
+  }
+  const ast = parse(code, { ...options, onLog: wrappedOnLog });
+  try {
+    const errors = validateSemantic(ast, { onLog: wrappedOnLog });
+    if (errors && errors.length > 0) {
+      if (options?.onLog) options.onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "warn", event: "parse.semantic.summary", detail: { count: errors.length } });
+    }
+  } catch (err) {
+    if (wrappedOnLog) wrappedOnLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "error", event: "parse.semantic.failed", detail: { error: String(err) } });
+  }
+  if (ast.evolve && ast.evolve.steps && ast.evolve.steps.length > 0) {
+    try {
+      const evolveResult = applyEvolve(ast, { onLog: wrappedOnLog });
+      if (evolveResult.changed && wrappedOnLog) {
+        wrappedOnLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "parse.evolve.summary", detail: { changed: true, stepsApplied: ast.evolve.steps.length } });
+      }
+    } catch (err) {
+      if (wrappedOnLog) wrappedOnLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "error", event: "parse.evolve.failed", detail: { error: String(err) } });
+    }
+  }
+  ast.isEny = true;
+  return ast;
+}
+
+// src/index.ts
+init_parser();
+init_tokenize();
+init_transpile();
+
+// src/ia/index.ts
+var LocalIA = class {
+  constructor() {
+    this.name = "LocalIA";
+    this.capabilities = /* @__PURE__ */ new Map();
+    this.capabilities.set("aprender", () => ({ learned: true }));
+    this.capabilities.set("sugerir", () => ({ suggestions: ["option1", "option2"] }));
+    this.capabilities.set("evoluir", () => ({ evolved: true }));
+    this.capabilities.set("analisar", () => ({ analysis: "completed" }));
+    this.capabilities.set("prever", () => ({ prediction: "success" }));
+    this.capabilities.set("otimizar", () => ({ optimized: true }));
+  }
+  async isAvailable() {
+    return true;
+  }
+  async process(ia, context) {
+    const log2 = context?.onLog;
+    if (log2) {
+      log2({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        event: "ia.process.start",
+        detail: { name: ia.name, capabilities: ia.body }
+      });
+    }
+    const results = {};
+    const processedCapabilities = [];
+    for (const capability of ia.body) {
+      const capName = capability.split(/\s+/)[0].toLowerCase();
+      const handler = this.capabilities.get(capName);
+      if (handler) {
+        results[capName] = handler();
+        processedCapabilities.push(capName);
+        if (log2) {
+          log2({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "debug",
+            event: "ia.capability.executed",
+            detail: { capability: capName, result: results[capName] }
+          });
+        }
+      } else {
+        results[capName] = { status: "acknowledged", raw: capability };
+        processedCapabilities.push(capName);
+        if (log2) {
+          log2({
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            level: "warn",
+            event: "ia.capability.unknown",
+            detail: { capability: capName, raw: capability }
+          });
+        }
+      }
+    }
+    if (log2) {
+      log2({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "info",
+        event: "ia.process.complete",
+        detail: { name: ia.name, processedCount: processedCapabilities.length }
+      });
+    }
+    return {
+      success: true,
+      result: results,
+      capabilities: processedCapabilities
+    };
+  }
+  /**
+   * Register a custom capability handler
+   */
+  registerCapability(name, handler) {
+    this.capabilities.set(name.toLowerCase(), handler);
+  }
+};
+var RemoteIA = class {
+  constructor(endpoint, apiKey) {
+    this.name = "RemoteIA";
+    this.endpoint = endpoint;
+    this.apiKey = apiKey;
+  }
+  async isAvailable() {
+    return false;
+  }
+  async process(ia, context) {
+    const log2 = context?.onLog;
+    if (log2) {
+      log2({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level: "warn",
+        event: "ia.remote.notImplemented",
+        detail: { endpoint: this.endpoint }
+      });
+    }
+    return {
+      success: false,
+      error: "RemoteIA is not implemented yet. Use LocalIA for development."
+    };
+  }
+};
+var IAManager = class {
+  constructor(defaultProvider) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.defaultProvider = defaultProvider || new LocalIA();
+    this.providers.set(this.defaultProvider.name, this.defaultProvider);
+  }
+  registerProvider(provider) {
+    this.providers.set(provider.name, provider);
+  }
+  getProvider(name) {
+    if (name && this.providers.has(name)) {
+      return this.providers.get(name);
+    }
+    return this.defaultProvider;
+  }
+  async processIA(ia, context, providerName) {
+    const provider = this.getProvider(providerName);
+    const available = await provider.isAvailable();
+    if (!available) {
+      if (provider.name !== "LocalIA") {
+        const localIA = this.providers.get("LocalIA") || new LocalIA();
+        return localIA.process(ia, context);
+      }
+      return {
+        success: false,
+        error: `Provider ${provider.name} is not available`
+      };
+    }
+    return provider.process(ia, context);
+  }
+};
+var defaultIAManager = new IAManager();
+async function processIA(ia, context, provider) {
+  const p = provider || new LocalIA();
+  return p.process(ia, context);
+}
+
+// src/symbols.ts
+var TRUE = true;
+var FALSE = false;
+var VOID = null;
+var NIL = void 0;
+var SYMBOLS2 = {
+  STATE: "\u03A3",
+  SUBSTATE: "\u03C3",
+  VOID: "\xD8",
+  TRUE: "\u22A4",
+  FALSE: "\u22A5",
+  LOCK: "\u{1F512}",
+  UNLOCK: "\u{1F513}",
+  STRING: "\u{1D54A}",
+  INTEGER: "\u2124",
+  REAL: "\u211D",
+  BOOLEAN: "\u{1D539}",
+  ARRAY: "\u{1D538}",
+  OBJECT: "\u{1D546}",
+  FUNCTION: "\u03BB",
+  PROMISE: "\u2119",
+  ANY: "\u229B",
+  NULL: "\u2205",
+  SHAPE: "\u25A0",
+  CLASS: "\u25CB",
+  INSTANCE: "\u25CF",
+  MODULE: "\u29C9",
+  FN: "\u0192",
+  LAMBDA: "\u03BB",
+  ASYNC: "\u03BB\u21C4",
+  MEMO: "\u03BB+",
+  ACTION: "\u0394",
+  EXEC: "\u2192",
+  IMPLIES: "\u21D2",
+  PARALLEL: "\u21C9",
+  ASSIGN: "\u2190",
+  DERIVE: "\u21D0",
+  NOT_EQUAL: "\u2260",
+  LTE: "\u2264",
+  GTE: "\u2265",
+  AND: "\u2227",
+  OR: "\u2228",
+  NOT: "\xAC",
+  MULT: "\xD7",
+  DIV: "\xF7",
+  MERGE: "\u2295",
+  IN: "\u2208",
+  UNION: "\u222A",
+  MAP: "\u21A6",
+  FILTER: "\u22B3",
+  REDUCE: "\u22B2",
+  FIND: "\u2299",
+  EVERY: "\u2200",
+  SOME: "\u2203",
+  EFFECT: "\u26A1",
+  EVENT: "\u25CC",
+  AWAIT: "\u21C4",
+  GET: "\u21C4 GET",
+  POST: "\u21C4 POST",
+  MEMORY: "\u{1D4DC}",
+  ROUTE: "\u{1F9ED}",
+  NAVIGATE: "\u{1F9ED}\u2192",
+  COMPONENT: "\u2610",
+  JSX_OPEN: "\u27E8",
+  JSX_CLOSE: "\u27E9",
+  PAGE: "\u2610.page",
+  CARD: "\u2610.card",
+  BTN: "\u2610.btn",
+  INPUT: "\u2610.input",
+  MODAL: "\u2610.modal",
+  SPINNER: "\u2610.spinner",
+  SECURITY: "\u{1F6E1}",
+  VALIDATE: "\u{1F6E1}!",
+  KEY: "\u{1F511}",
+  EVOLVE: "\u27F3",
+  AI: "\u03A8",
+  LOG: "\u{1F4DC}",
+  INTERVAL: "\u21BB",
+  IMPORT: "\u29C9",
+  EXPORT: "\u2191"
+};
+var TRANSPILE_MAP = {
+  "\u03A3[": "const [",
+  "\xD8": "null",
+  "\u22A4": "true",
+  "\u22A5": "false",
+  "\u{1D54A}": "string",
+  "\u2124": "number",
+  "\u211D": "number",
+  "\u{1D539}": "boolean",
+  "\u{1D538}": "Array",
+  "\u{1D546}": "object",
+  "\u03BB": "() =>",
+  "\u2119": "Promise",
+  "\u25A0": "interface",
+  "\u25CB": "class",
+  "\u25CF": "new",
+  "\u0192": "function",
+  "\u2192": "=>",
+  "\u21D2": "?",
+  "\u21C9": "Promise.all",
+  "\u2190": "=",
+  "\u2260": "!==",
+  "\u2264": "<=",
+  "\u2265": ">=",
+  "\u2227": "&&",
+  "\u2228": "||",
+  "\xAC": "!",
+  "\xD7": "*",
+  "\xF7": "/",
+  "\u21A6": ".map(",
+  "\u22B3": ".filter(",
+  "\u22B2": ".reduce(",
+  "\u2299": ".find(",
+  "\u2200": ".every(",
+  "\u2203": ".some(",
+  "\u26A1[]": "useEffect(() => {",
+  "\u25CC.click": "onClick",
+  "\u25CC.change": "onChange",
+  "\u25CC.submit": "onSubmit",
+  "\u21C4": "await",
+  "\u21C4 GET": "await fetch(",
+  "\u{1D4DC}[": "localStorage.getItem(",
+  "\u{1D4DC}\u2190": "localStorage.setItem(",
+  "\u{1F9ED}\u2192": "navigate(",
+  "\u2610": "function Component",
+  "\u27E8": "<",
+  "\u27E9": ">",
+  "\u{1F4DC}": "console.log(",
+  "\u26D4": "throw new Error(",
+  "\u21BB": "setInterval("
+};
+function transpileSymbols(code) {
+  let result = code;
+  const sortedKeys = Object.keys(TRANSPILE_MAP).sort((a, b) => b.length - a.length);
+  for (const symbol of sortedKeys) {
+    result = result.split(symbol).join(TRANSPILE_MAP[symbol]);
+  }
+  return result;
+}
+function toSymbolic(code) {
+  let result = code;
+  const inverseMap = {};
+  for (const [symbol, js] of Object.entries(TRANSPILE_MAP)) {
+    inverseMap[js] = symbol;
+  }
+  const sortedKeys = Object.keys(inverseMap).sort((a, b) => b.length - a.length);
+  for (const js of sortedKeys) {
+    result = result.split(js).join(inverseMap[js]);
+  }
+  return result;
+}
+var state = (name, initial) => `const [${name}, set${name.charAt(0).toUpperCase() + name.slice(1)}] = useState(${JSON.stringify(initial)});`;
+var effect = (body, deps = []) => `useEffect(() => { ${body} }, [${deps.join(", ")}]);`;
+var fn = (name, params, body) => `function ${name}(${params.join(", ")}) { ${body} }`;
+var asyncFn = (name, params, body) => `async function ${name}(${params.join(", ")}) { ${body} }`;
+var component = (name, body) => `function ${name}() { ${body} }`;
+var shape = (name, fields) => {
+  const fieldStrs = Object.entries(fields).map(([k, v]) => `  ${k}: ${v};`).join("\n");
+  return `interface ${name} {
+${fieldStrs}
+}`;
+};
+var get = (url) => `await fetch(${JSON.stringify(url)}).then(r => r.json())`;
+var post = (url, body) => `await fetch(${JSON.stringify(url)}, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(${body}) }).then(r => r.json())`;
+var navigate = (path) => `navigate(${JSON.stringify(path)})`;
+var map = (arr, cb) => `${arr}.map(${cb})`;
+var filter = (arr, pred) => `${arr}.filter(${pred})`;
+var reduce = (arr, red, init) => `${arr}.reduce(${red}, ${init})`;
+var find = (arr, pred) => `${arr}.find(${pred})`;
+var storageGet = (key) => `localStorage.getItem(${JSON.stringify(key)})`;
+var storageSet = (key, val) => `localStorage.setItem(${JSON.stringify(key)}, JSON.stringify(${val}))`;
+var validate = (schema, data) => `validate(${schema}, ${data})`;
+var log = (msg) => `console.log(${msg})`;
+var error = (msg) => `throw new Error(${JSON.stringify(msg)})`;
+var ALPHABET = {
+  STATE: { symbol: "\u03A3", js: "useState", desc: "Estado global" },
+  SUBSTATE: { symbol: "\u03C3", js: "localState", desc: "Estado local" },
+  VOID: { symbol: "\xD8", js: "null", desc: "N\xE3o-exist\xEAncia" },
+  TRUE: { symbol: "\u22A4", js: "true", desc: "Verdadeiro" },
+  FALSE: { symbol: "\u22A5", js: "false", desc: "Falso" },
+  STRING: { symbol: "\u{1D54A}", js: "string", desc: "Texto" },
+  INTEGER: { symbol: "\u2124", js: "number", desc: "Inteiro" },
+  REAL: { symbol: "\u211D", js: "number", desc: "Real" },
+  BOOLEAN: { symbol: "\u{1D539}", js: "boolean", desc: "Booleano" },
+  ARRAY: { symbol: "\u{1D538}", js: "Array", desc: "Lista" },
+  OBJECT: { symbol: "\u{1D546}", js: "object", desc: "Objeto" },
+  FUNCTION: { symbol: "\u03BB", js: "() =>", desc: "Fun\xE7\xE3o" },
+  FN: { symbol: "\u0192", js: "function", desc: "Fun\xE7\xE3o nomeada" },
+  SHAPE: { symbol: "\u25A0", js: "interface", desc: "Interface" },
+  CLASS: { symbol: "\u25CB", js: "class", desc: "Classe" },
+  INSTANCE: { symbol: "\u25CF", js: "new", desc: "Inst\xE2ncia" },
+  EXEC: { symbol: "\u2192", js: "=>", desc: "Execu\xE7\xE3o" },
+  ASSIGN: { symbol: "\u2190", js: "=", desc: "Atribui\xE7\xE3o" },
+  AND: { symbol: "\u2227", js: "&&", desc: "E l\xF3gico" },
+  OR: { symbol: "\u2228", js: "||", desc: "Ou l\xF3gico" },
+  NOT: { symbol: "\xAC", js: "!", desc: "Nega\xE7\xE3o" },
+  MAP: { symbol: "\u21A6", js: ".map", desc: "Mapear" },
+  FILTER: { symbol: "\u22B3", js: ".filter", desc: "Filtrar" },
+  REDUCE: { symbol: "\u22B2", js: ".reduce", desc: "Reduzir" },
+  FIND: { symbol: "\u2299", js: ".find", desc: "Encontrar" },
+  EFFECT: { symbol: "\u26A1", js: "useEffect", desc: "Efeito" },
+  EVENT: { symbol: "\u25CC", js: "on", desc: "Evento" },
+  AWAIT: { symbol: "\u21C4", js: "await", desc: "Async" },
+  MEMORY: { symbol: "\u{1D4DC}", js: "localStorage", desc: "Storage" },
+  ROUTE: { symbol: "\u{1F9ED}", js: "router", desc: "Rota" },
+  NAVIGATE: { symbol: "\u{1F9ED}\u2192", js: "navigate", desc: "Navegar" },
+  COMPONENT: { symbol: "\u2610", js: "function", desc: "Componente" },
+  SECURITY: { symbol: "\u{1F6E1}", js: "security", desc: "Seguran\xE7a" },
+  EVOLVE: { symbol: "\u27F3", js: "evolve", desc: "Evoluir" },
+  AI: { symbol: "\u03A8", js: "ai", desc: "IA" },
+  LOG: { symbol: "\u{1F4DC}", js: "console.log", desc: "Log" },
+  INTERVAL: { symbol: "\u21BB", js: "setInterval", desc: "Intervalo" }
+};
+
+// src/pillars.ts
+function createSystem(config) {
+  const lines = [];
+  lines.push(`\u03A3 SYSTEM "${config.name}"`);
+  if (config.mode) lines.push(`\u03A3 MODE ${config.mode}`);
+  if (config.ui) lines.push(`\u03A3 UI ${config.ui}`);
+  if (config.evolve) lines.push(`\u03A3 EVOLVE true`);
+  if (config.targets?.length) {
+    lines.push(`\u03A3 TARGET ${config.targets.join(" + ")}`);
+  }
+  return lines.join("\n");
+}
+function getState(ast) {
+  return {
+    system: ast.system,
+    mode: ast.mode,
+    ui: ast.ui,
+    version: ast.version,
+    isEny: ast.isEny,
+    substates: ast.substates || []
+  };
+}
+function createFunction(name, args, steps) {
+  const argsStr = args.length ? `(${args.join(", ")})` : "";
+  const stepsStr = steps.map((s) => `  \u2192 ${s}`).join("\n");
+  return `\u0394 function ${name}${argsStr}
+${stepsStr}`;
+}
+function getFunctions(ast) {
+  return ast.functions || [];
+}
+function createObject(name, props) {
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${JSON.stringify(v)}`).join("\n");
+  return `\u03A9 ${name} {
+${propsStr}
+}`;
+}
+function createClass(name, props, methods = [], extendsClass) {
+  const extendsStr = extendsClass ? ` \u2192 ${extendsClass}` : "";
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${typeof v}`).join("\n");
+  const methodsStr = methods.map((m) => `  ${m}()`).join("\n");
+  return `\u25CB ${name}${extendsStr} {
+${propsStr}
+${methodsStr}
+}`;
+}
+function getStructures(ast) {
+  return {
+    objects: ast.objects || [],
+    classes: ast.classes || [],
+    modules: ast.modules || []
+  };
+}
+function createEvent(name, handlers) {
+  const handlersStr = handlers.map((h) => `  \u2192 ${h}`).join("\n");
+  return `\u25CC ${name}
+${handlersStr}`;
+}
+function createLoop(count, body) {
+  const bodyStr = body.map((b) => `  ${b}`).join("\n");
+  return `\u21BB ${count} {
+${bodyStr}
+}`;
+}
+function getTemporals(ast) {
+  return {
+    events: ast.events || [],
+    loops: ast.loops || [],
+    causes: ast.causes || [],
+    timeouts: ast.timeouts || [],
+    delays: ast.delays || [],
+    syncs: ast.syncs || []
+  };
+}
+function createThrottle(target, limit) {
+  return `\u23EC ${target} ${limit}`;
+}
+function createBoost(target, factor) {
+  return `\u23EB ${target} ${factor}`;
+}
+function getEnergy(ast) {
+  return {
+    throttles: ast.throttles || [],
+    boosts: ast.boosts || [],
+    costs: ast.costs || []
+  };
+}
+function createMemory(name, size, persist = false) {
+  return `\u{1D4DC} ${name} ${size}${persist ? " persist" : ""}`;
+}
+function createPersist(target, storage = "db") {
+  return `\u267E ${target} ${storage}`;
+}
+function getMemory(ast) {
+  return {
+    database: ast.database,
+    memories: ast.memories || [],
+    persists: ast.persists || []
+  };
+}
+function createInput(name, type = "text") {
+  return `\u2328 ${name} ${type}`;
+}
+function createVisual(name, props) {
+  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${v}`).join("\n");
+  return `\u{1F441} ${name} {
+${propsStr}
+}`;
+}
+function getInterface(ast) {
+  return {
+    forms: ast.forms || [],
+    inputs: ast.inputs || [],
+    visuals: ast.visuals || [],
+    interfaces: ast.interfaces || []
+  };
+}
+function createSecurity(level, rules) {
+  const rulesStr = rules.map((r) => `  ${r}`).join("\n");
+  return `\u{1F6E1} ${level} {
+${rulesStr}
+}`;
+}
+function createKey(name, permissions) {
+  const permsStr = permissions.map((p) => `  ${p}`).join("\n");
+  return `\u{1F511} ${name} {
+${permsStr}
+}`;
+}
+function getSecurity(ast) {
+  return {
+    securities: ast.securities || [],
+    keys: ast.keys || [],
+    sandboxes: ast.sandboxes || [],
+    locks: ast.locks || [],
+    unlocks: ast.unlocks || []
+  };
+}
+function createEvolve(steps) {
+  const stepsStr = steps.map((s) => `  ${s}`).join("\n");
+  return `\u27F3 {
+${stepsStr}
+}`;
+}
+function getEvolve(ast) {
+  return {
+    evolve: ast.evolve,
+    verifies: ast.verifies || [],
+    logNodes: ast.logNodes || []
+  };
+}
+function generateENY(config) {
+  const parts = [];
+  parts.push(`\u03A3 SYSTEM "${config.system.name}"`);
+  if (config.system.mode) parts.push(`\u03A3 MODE ${config.system.mode}`);
+  if (config.system.ui) parts.push(`\u03A3 UI ${config.system.ui}`);
+  parts.push("");
+  for (const fn2 of config.functions || []) {
+    parts.push(createFunction(fn2.name, fn2.args || [], fn2.steps));
+    parts.push("");
+  }
+  for (const obj of config.objects || []) {
+    parts.push(createObject(obj.name, obj.props));
+    parts.push("");
+  }
+  for (const evt of config.events || []) {
+    parts.push(createEvent(evt.name, evt.handlers));
+    parts.push("");
+  }
+  if (config.security) {
+    parts.push(createSecurity(config.security.level, config.security.rules));
+    parts.push("");
+  }
+  if (config.evolve?.length) {
+    parts.push(createEvolve(config.evolve));
+  }
+  return parts.join("\n").trim();
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var NAME = "eny-ai";
+var STATE = /* @__PURE__ */ Symbol("STATE");
+var SUBSTATE = /* @__PURE__ */ Symbol("SUBSTATE");
+var VOID_VAL = null;
+var TRUE_VAL = true;
+var FALSE_VAL = false;
+var OBJECT = /* @__PURE__ */ Symbol("OBJECT");
+var FUNCTION = /* @__PURE__ */ Symbol("FUNCTION");
+var INTERFACE = /* @__PURE__ */ Symbol("INTERFACE");
+var SHIELD = /* @__PURE__ */ Symbol("SECURITY");
+var EVOLVE = /* @__PURE__ */ Symbol("EVOLVE");
+function quickSystem(name, config) {
+  return createSystem({
+    name,
+    mode: config?.mode || "development",
+    ui: config?.ui || "auto",
+    evolve: config?.evolve || false
+  });
+}
+function compile(enyCode) {
+  const { transpileToJS: transpileToJS2 } = (init_transpile(), __toCommonJS(transpile_exports));
+  const { parse: parse2 } = (init_parser(), __toCommonJS(parser_exports));
+  const ast = parse2(enyCode);
+  return transpileToJS2(ast);
+}
+function isValidENY(code) {
+  try {
+    const { parse: parse2 } = (init_parser(), __toCommonJS(parser_exports));
+    const ast = parse2(code);
+    return ast.isEny === true;
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALPHABET,
+  EVOLVE,
+  FALSE,
+  FALSE_VAL,
+  FUNCTION,
+  IAManager,
+  INTERFACE,
+  LocalIA,
+  NAME,
+  NIL,
+  OBJECT,
+  RemoteIA,
+  SHIELD,
+  STATE,
+  SUBSTATE,
+  SYMBOLS,
+  SYMBOL_NAMES,
+  TRANSPILE_MAP,
+  TRUE,
+  TRUE_VAL,
+  TokenType,
+  VERSION,
+  VOID,
+  VOID_VAL,
+  applyEvolve,
+  asyncFn,
+  compile,
+  component,
+  createBoost,
+  createClass,
+  createEvent,
+  createEvolve,
+  createFunction,
+  createInput,
+  createKey,
+  createLoop,
+  createMemory,
+  createObject,
+  createPersist,
+  createSecurity,
+  createSystem,
+  createThrottle,
+  createVisual,
+  defaultIAManager,
+  effect,
+  error,
+  filter,
+  find,
+  fn,
+  generateENY,
+  get,
+  getEnergy,
+  getEvolve,
+  getFunctions,
+  getInterface,
+  getMemory,
+  getSecurity,
+  getState,
+  getStructures,
+  getTemporals,
+  hasWASMTarget,
+  isValidENY,
+  log,
+  map,
+  navigate,
+  parse,
+  post,
+  processIA,
+  quickSystem,
+  reduce,
+  runENY,
+  shape,
+  state,
+  storageGet,
+  storageSet,
+  toSymbolic,
+  tokenize,
+  transpileSymbols,
+  transpileToDTS,
+  transpileToJS,
+  transpileToWAT,
+  validate,
+  validateSemantic,
+  validateSemanticFull
+});