eny-ai 1.0.0 → 2.0.0

package/dist/index.cjs

@@ -30,7 +30,911 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  ENYRuntime: () => ENYRuntime,
+  eny: () => eny,
+  filterArray: () => filterArray,
+  func: () => func,
+  lambda: () => lambda,
+  mapArray: () => mapArray,
+  reduceArray: () => reduceArray,
+  state: () => state2,
+  substate: () => substate
+});
+var ENYRuntime, eny, state2, substate, func, lambda, mapArray, filterArray, reduceArray;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    "use strict";
+    init_cjs_shims();
+    ENYRuntime = class {
+      constructor() {
+        this.context = {};
+        this.hooks = /* @__PURE__ */ new Map();
+        this.effects = [];
+        // ════════════════════════════════════════════════════════════════
+        // SÍMBOLOS HTTP/ASYNC
+        // ════════════════════════════════════════════════════════════════
+        /**
+         * http - HTTP methods
+         * http.GET(url), http.POST(url, data), etc
+         * Alias: ⇄
+         */
+        this.http = {
+          GET: async (url) => {
+            const res = await fetch(url);
+            return res.json();
+          },
+          POST: async (url, data) => {
+            const res = await fetch(url, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(data)
+            });
+            return res.json();
+          },
+          PUT: async (url, data) => {
+            const res = await fetch(url, {
+              method: "PUT",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(data)
+            });
+            return res.json();
+          },
+          DELETE: async (url) => {
+            const res = await fetch(url, { method: "DELETE" });
+            return res.json();
+          }
+        };
+        // ════════════════════════════════════════════════════════════════
+        // SÍMBOLOS MEMÓRIA/STORAGE
+        // ════════════════════════════════════════════════════════════════
+        /**
+         * storage - Memory/Storage access
+         * storage.get(key), storage.set(key, value)
+         * Alias: 𝓜
+         */
+        this.storage = {
+          get: (key) => localStorage.getItem(key),
+          set: (key, value) => localStorage.setItem(key, JSON.stringify(value)),
+          remove: (key) => localStorage.removeItem(key),
+          clear: () => localStorage.clear(),
+          session: {
+            get: (key) => sessionStorage.getItem(key),
+            set: (key, value) => sessionStorage.setItem(key, JSON.stringify(value))
+          }
+        };
+        // ════════════════════════════════════════════════════════════════
+        // SÍMBOLOS SEGURANÇA
+        // ════════════════════════════════════════════════════════════════
+        /**
+         * validate - Validation helpers
+         * validate.email(str), validate.min(len)
+         * Alias: 🛡
+         */
+        this.validate = {
+          email: (str) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str),
+          min: (len) => (str) => str.length >= len,
+          max: (len) => (str) => str.length <= len,
+          regex: (pattern) => (str) => pattern.test(str),
+          required: (val) => val != null && val !== "",
+          equals: (expected) => (actual) => actual === expected
+        };
+        this.crypto = {
+          lock: (obj) => Object.freeze(obj),
+          unlock: (obj) => Object.assign({}, obj)
+        };
+        // ════════════════════════════════════════════════════════════════
+        // SÍMBOLOS NAVEGAÇÃO
+        // ════════════════════════════════════════════════════════════════
+        /**
+         * router - Router/Navigation
+         * router.navigate(path), router.back()
+         * Alias: 🧭
+         */
+        this.router = {
+          navigate: (path) => window.location.href = path,
+          back: () => window.history.back(),
+          forward: () => window.history.forward(),
+          reload: () => window.location.reload(),
+          params: () => new URLSearchParams(window.location.search)
+        };
+        // ════════════════════════════════════════════════════════════════
+        // SISTEMA DE LOGS
+        // ════════════════════════════════════════════════════════════════
+        /**
+         * logger - Logging system
+         * logger.info(msg), logger.error(msg), logger.warn(msg)
+         * Alias: 📜
+         */
+        this.logger = {
+          info: (msg, data) => console.log(`\u2139\uFE0F ${msg}`, data),
+          error: (msg, data) => console.error(`\u274C ${msg}`, data),
+          warn: (msg, data) => console.warn(`\u26A0\uFE0F ${msg}`, data),
+          log: (msg, data) => console.log(`\u{1F4DC} ${msg}`, data)
+        };
+      }
+      // ════════════════════════════════════════════════════════════════
+      // SÍMBOLOS BÁSICOS - ESTADO
+      // ════════════════════════════════════════════════════════════════
+      /**
+       * Σ - Cria estado global
+       * Σ('user', { name: 'João' })
+       */
+      \u03A3(key, initialValue) {
+        if (!this.context[key]) {
+          this.context[key] = initialValue;
+        }
+        return {
+          get: () => this.context[key],
+          set: (value) => {
+            this.context[key] = value;
+            this.notify();
+          },
+          value: this.context[key]
+        };
+      }
+      /**
+       * σ - Sub-estado (local)
+       * σ(parent, 'field')
+       */
+      \u03C3(parent, field) {
+        return {
+          get: () => parent[field],
+          set: (value) => {
+            parent[field] = value;
+          },
+          value: parent[field]
+        };
+      }
+      /**
+       * ⊤ e ⊥ - Booleanos
+       */
+      get TRUE() {
+        return true;
+      }
+      get FALSE() {
+        return false;
+      }
+      // Aliases simbólicos para compatibilidade
+      get trueValue() {
+        return true;
+      }
+      get falseValue() {
+        return false;
+      }
+      /**
+       * Ø - Nulo/Vazio
+       */
+      get \u00D8() {
+        return null;
+      }
+      // ════════════════════════════════════════════════════════════════
+      // SÍMBOLOS FUNCIONAIS - FUNÇÕES
+      // ════════════════════════════════════════════════════════════════
+      /**
+       * func - Define função normal
+       * func('myFunc', (a, b) => a + b)
+       */
+      func(name, fn2) {
+        const wrapped = fn2;
+        this.context[name] = wrapped;
+        return wrapped;
+      }
+      // Alias: ƒ
+      get \u0192() {
+        return this.func.bind(this);
+      }
+      /**
+       * lambda - Arrow function/Lambda
+       * lambda(fn) - wraps e memoiza
+       */
+      lambda(fn2) {
+        return fn2;
+      }
+      // Alias: λ
+      get \u03BB() {
+        return this.lambda.bind(this);
+      }
+      // ════════════════════════════════════════════════════════════════
+      // SÍMBOLOS DE ARRAY - ITERAÇÃO
+      // ════════════════════════════════════════════════════════════════
+      /**
+       * map - Map operator
+       * arr.map((item) => item * 2)
+       * Alias: ↦
+       */
+      map(arr, fn2) {
+        return arr.map((item) => fn2(item));
+      }
+      /**
+       * filter - Filter operator
+       * arr.filter((item) => item > 5)
+       * Alias: ⊳
+       */
+      filter(arr, predicate) {
+        return arr.filter((item) => predicate(item));
+      }
+      /**
+       * reduce - Reduce operator
+       * arr.reduce((acc, item) => acc + item, 0)
+       * Alias: ⊲
+       */
+      reduce(arr, reducer, initial = 0) {
+        return arr.reduce((acc, item) => reducer(acc, item), initial);
+      }
+      /**
+       * find - Find operator
+       * arr.find((item) => item.id === 5)
+       * Alias: ⊙
+       */
+      find(arr, predicate) {
+        return arr.find((item) => predicate(item));
+      }
+      /**
+       * every - Every operator
+       * arr.every((item) => item > 0)
+       * Alias: ∀
+       */
+      every(arr, predicate) {
+        return arr.every((item) => predicate(item));
+      }
+      /**
+       * some - Some operator
+       * arr.some((item) => item > 0)
+       * Alias: ∃
+       */
+      some(arr, predicate) {
+        return arr.some((item) => predicate(item));
+      }
+      // ════════════════════════════════════════════════════════════════
+      // SÍMBOLOS OPERADORES
+      // ════════════════════════════════════════════════════════════════
+      /**
+       * assign - Assignment operator
+       * Alias: ←
+       */
+      assign(target, value) {
+        return value;
+      }
+      /**
+       * and - AND operator
+       * Alias: ∧
+       */
+      and(a, b) {
+        return a && b;
+      }
+      /**
+       * or - OR operator
+       * Alias: ∨
+       */
+      or(a, b) {
+        return a || b;
+      }
+      /**
+       * not - NOT operator
+       * Alias: ¬
+       */
+      not(a) {
+        return !a;
+      }
+      /**
+       * merge - Merge/Spread operator
+       * Alias: ⊕
+       */
+      merge(...objs) {
+        return Object.assign({}, ...objs);
+      }
+      /**
+       * encode - Basic encoding/decoding
+       * Alias: 🔑 🔒 🔓
+       */
+      encode(data) {
+        return btoa(data);
+      }
+      // ════════════════════════════════════════════════════════════════
+      // INTERNALS
+      // ════════════════════════════════════════════════════════════════
+      notify() {
+        this.effects.forEach((effect2) => effect2());
+      }
+      /**
+       * effect - Register effect function
+       * Alias: ⚡
+       */
+      effect(fn2, deps = []) {
+        this.effects.push(() => fn2());
+      }
+      /**
+       * Obter todo contexto
+       */
+      getContext() {
+        return { ...this.context };
+      }
+      /**
+       * Limpar runtime
+       */
+      clear() {
+        this.context = {};
+        this.hooks.clear();
+        this.effects = [];
+      }
+    };
+    eny = new ENYRuntime();
+    state2 = eny.\u03A3.bind(eny);
+    substate = eny.\u03C3.bind(eny);
+    func = eny.func.bind(eny);
+    lambda = eny.lambda.bind(eny);
+    mapArray = eny.map.bind(eny);
+    filterArray = eny.filter.bind(eny);
+    reduceArray = eny.reduce.bind(eny);
+  }
+});
+
+// src/firebase/index.ts
+var firebase_exports = {};
+__export(firebase_exports, {
+  ENYFirebase: () => ENYFirebase,
+  firebase: () => firebase,
+  useAuth: () => useAuth,
+  useFirebase: () => useFirebase,
+  useRealtimeData: () => useRealtimeData
+});
+function useFirebase() {
+  return firebase;
+}
+function useAuth(callback) {
+  const [user, setUser] = import_react2.default.useState(null);
+  const [loading, setLoading] = import_react2.default.useState(true);
+  import_react2.default.useEffect(() => {
+    const unsubscribe = firebase.onAuthStateChange((u) => {
+      setUser(u);
+      setLoading(false);
+      callback?.(u);
+    });
+    return () => unsubscribe();
+  }, [callback]);
+  return { user, loading };
+}
+function useRealtimeData(path) {
+  const [data, setData] = import_react2.default.useState(null);
+  const [loading, setLoading] = import_react2.default.useState(true);
+  import_react2.default.useEffect(() => {
+    const unsubscribe = firebase.watch(path, (d) => {
+      setData(d);
+      setLoading(false);
+    });
+    return () => unsubscribe();
+  }, [path]);
+  return { data, loading };
+}
+var import_app, import_auth, import_database, import_react2, ENYFirebase, firebase;
+var init_firebase = __esm({
+  "src/firebase/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_app = require("firebase/app");
+    import_auth = require("firebase/auth");
+    import_database = require("firebase/database");
+    import_react2 = __toESM(require("react"), 1);
+    ENYFirebase = class {
+      constructor() {
+        this.app = null;
+        this.auth = null;
+        this.db = null;
+      }
+      /**
+       * ⚙️ - Inicializar Firebase
+       */
+      initialize(config) {
+        this.app = (0, import_app.initializeApp)(config);
+        this.auth = (0, import_auth.getAuth)(this.app);
+        this.db = (0, import_database.getDatabase)(this.app);
+        console.log("\u2705 Firebase inicializado");
+      }
+      // ═════════════════════════════════════════════════════════════════════════════
+      // MÉTODOS AUTENTICAÇÃO
+      // ═════════════════════════════════════════════════════════════════════════════
+      /**
+       * signin - Login com email/senha
+       * signin(email, password)
+       * Alias: 🔑(email, password)
+       */
+      async signin(email, password) {
+        if (!this.auth) throw new Error("Firebase not initialized");
+        try {
+          const credential = await (0, import_auth.signInWithEmailAndPassword)(this.auth, email, password);
+          console.log("\u2705 Login bem-sucedido:", email);
+          return {
+            user: credential.user,
+            success: true
+          };
+        } catch (error2) {
+          console.error("\u274C Erro login:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * signup - Criar conta
+       * signup(email, password)
+       * Alias: 📝(email, password)
+       */
+      async signup(email, password) {
+        if (!this.auth) throw new Error("Firebase not initialized");
+        try {
+          const credential = await (0, import_auth.createUserWithEmailAndPassword)(this.auth, email, password);
+          console.log("\u2705 Conta criada:", email);
+          return {
+            user: credential.user,
+            success: true
+          };
+        } catch (error2) {
+          console.error("\u274C Erro criar conta:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * signout - Logout
+       * signout()
+       * Alias: 🚪()
+       */
+      async signout() {
+        if (!this.auth) throw new Error("Firebase not initialized");
+        try {
+          await (0, import_auth.signOut)(this.auth);
+          console.log("\u{1F44B} Desconectado");
+          return { success: true };
+        } catch (error2) {
+          console.error("\u274C Erro logout:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * currentUser - Obter usuário atual
+       * Alias: 👤
+       */
+      get currentUser() {
+        return this.auth?.currentUser || null;
+      }
+      /**
+       * onAuthStateChange - Observar estado autenticação
+       * onAuthStateChange((user) => {...})
+       * Alias: 👁((user) => {...})
+       */
+      onAuthStateChange(callback) {
+        if (!this.auth) throw new Error("Firebase not initialized");
+        return (0, import_auth.onAuthStateChanged)(this.auth, callback);
+      }
+      // ═════════════════════════════════════════════════════════════════════════════
+      // MÉTODOS DATABASE
+      // ═════════════════════════════════════════════════════════════════════════════
+      /**
+       * write - Escrever dados
+       * write('users/123', { name: 'João' })
+       * Alias: 📊(path, data)
+       */
+      async write(path, data) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        try {
+          const dbRef = (0, import_database.ref)(this.db, path);
+          await (0, import_database.set)(dbRef, data);
+          console.log("\u2705 Dados salvos:", path);
+          return { success: true };
+        } catch (error2) {
+          console.error("\u274C Erro salvar:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * read - Ler dados (uma vez)
+       * read('users/123')
+       * Alias: 🔍('users/123')
+       */
+      async read(path) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        try {
+          const dbRef = (0, import_database.ref)(this.db, path);
+          const snapshot = await (0, import_database.get)(dbRef);
+          console.log("\u2705 Dados lidos:", path);
+          return snapshot.val();
+        } catch (error2) {
+          console.error("\u274C Erro ler:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * watch - Observar dados em tempo real
+       * watch('users/123', (data) => {...})
+       * Alias: 📡('users/123', (data) => {...})
+       */
+      watch(path, callback) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        const dbRef = (0, import_database.ref)(this.db, path);
+        return (0, import_database.onValue)(dbRef, (snapshot) => {
+          callback(snapshot.val());
+        });
+      }
+      /**
+       * update - Atualizar dados específicos
+       * update('users/123', { name: 'João Silva' })
+       * Alias: ✏️('users/123', { name: 'João Silva' })
+       */
+      async updateData(path, data) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        try {
+          const dbRef = (0, import_database.ref)(this.db, path);
+          await (0, import_database.update)(dbRef, data);
+          console.log("\u2705 Dados atualizados:", path);
+          return { success: true };
+        } catch (error2) {
+          console.error("\u274C Erro atualizar:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * delete - Deletar dados
+       * delete('users/123')
+       * Alias: 🗑️('users/123')
+       */
+      async delete(path) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        try {
+          const dbRef = (0, import_database.ref)(this.db, path);
+          await (0, import_database.remove)(dbRef);
+          console.log("\u2705 Dados deletados:", path);
+          return { success: true };
+        } catch (error2) {
+          console.error("\u274C Erro deletar:", error2);
+          throw error2;
+        }
+      }
+      /**
+       * query - Query com ordem/limite
+       * query('users', 'age', 10)
+       * Alias: 🔗('users', 'age', 10)
+       */
+      async queryData(path, orderBy = "", limit = 0) {
+        if (!this.db) throw new Error("Firebase not initialized");
+        try {
+          const dbRef = (0, import_database.ref)(this.db, path);
+          let q = dbRef;
+          if (orderBy) {
+            q = (0, import_database.query)(dbRef, (0, import_database.orderByChild)(orderBy));
+          }
+          if (limit) {
+            q = (0, import_database.query)(dbRef, (0, import_database.limitToFirst)(limit));
+          }
+          const snapshot = await (0, import_database.get)(q);
+          return snapshot.val();
+        } catch (error2) {
+          console.error("\u274C Erro query:", error2);
+          throw error2;
+        }
+      }
+      // ═════════════════════════════════════════════════════════════════════════════
+      // HELPERS
+      // ═════════════════════════════════════════════════════════════════════════════
+      /**
+       * 🔐 - Contexto de autenticação
+       */
+      getAuth() {
+        return this.auth;
+      }
+      /**
+       * 📂 - Contexto de database
+       */
+      getDatabase() {
+        return this.db;
+      }
+      /**
+       * Verificar se está autenticado
+       */
+      isAuthenticated() {
+        return this.currentUser !== null;
+      }
+    };
+    firebase = new ENYFirebase();
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ALPHABET: () => ALPHABET,
+  ENYFirebase: () => ENYFirebase,
+  ENYRuntime: () => ENYRuntime,
+  EnyContext: () => EnyContext,
+  EnyUI: () => EnyUI,
+  EnyValidate: () => EnyValidate,
+  FALSE: () => FALSE,
+  IAManager: () => IAManager,
+  LocalIA: () => LocalIA,
+  NAME: () => NAME,
+  NIL: () => NIL,
+  RemoteIA: () => RemoteIA,
+  SYMBOLS: () => SYMBOLS2,
+  SYMBOL_NAMES: () => SYMBOL_NAMES,
+  TRANSPILE_MAP: () => TRANSPILE_MAP,
+  TRUE: () => TRUE,
+  TokenType: () => TokenType,
+  VERSION: () => VERSION,
+  VOID: () => VOID,
+  applyEvolve: () => applyEvolve,
+  asyncFn: () => asyncFn,
+  component: () => component,
+  createEnySystem: () => createEnySystem,
+  defaultIAManager: () => defaultIAManager,
+  effect: () => effect,
+  error: () => error,
+  filter: () => filter,
+  find: () => find,
+  firebase: () => firebase,
+  fn: () => fn,
+  get: () => get,
+  hasWASMTarget: () => hasWASMTarget,
+  initializeEnyFirebase: () => initializeEnyFirebase,
+  log: () => log,
+  map: () => map,
+  navigate: () => navigate,
+  parse: () => parse,
+  post: () => post,
+  processIA: () => processIA,
+  reduce: () => reduce,
+  runENY: () => runENY,
+  shape: () => shape,
+  state: () => state,
+  storageGet: () => storageGet,
+  storageSet: () => storageSet,
+  toSymbolic: () => toSymbolic,
+  tokenize: () => tokenize,
+  transpileSymbols: () => transpileSymbols,
+  transpileToDTS: () => transpileToDTS,
+  transpileToJS: () => transpileToJS,
+  transpileToWAT: () => transpileToWAT,
+  useAuth: () => useAuth,
+  useCallbackWithDeps: () => useCallbackWithDeps,
+  useEnyEffect: () => useEnyEffect,
+  useEnyFetch: () => useEnyFetch,
+  useEnyState: () => useEnyState,
+  useFirebase: () => useFirebase,
+  useLogger: () => useLogger,
+  useMemoWithDeps: () => useMemoWithDeps,
+  useNavigation: () => useNavigation,
+  usePersistentState: () => usePersistentState,
+  useRealtimeData: () => useRealtimeData,
+  useReducerWithState: () => useReducerWithState,
+  useValidation: () => useValidation,
+  validate: () => validate,
+  validateSemantic: () => validateSemantic,
+  validateSemanticFull: () => validateSemanticFull
+});
+module.exports = __toCommonJS(src_exports);
+init_cjs_shims();
+
+// src/runENY.ts
+init_cjs_shims();
+
+// src/parser.ts
+init_cjs_shims();
+
+// src/parser/ebnfParser.ts
+init_cjs_shims();
+
 // src/lexer/tokenize.ts
+init_cjs_shims();
+var 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 || {});
+var 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
+]);
+var 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
+]);
+var 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
+]);
+var 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
+]);
+var SYMBOLS_ENERGY = /* @__PURE__ */ new Set([
+  "\u03A8",
+  // ENERGY - Energia vital
+  "\u23EC",
+  // THROTTLE - Limitar
+  "\u23EB",
+  // BOOST - Acelerar
+  "\u20B5"
+  // COST - Custo
+]);
+var SYMBOLS_MEMORY = /* @__PURE__ */ new Set([
+  "\u{1D4DC}",
+  // MEMORY - Memória
+  "\u267E",
+  // PERSIST - Persistência
+  "\u2302"
+  // ROOT - Raiz do sistema
+]);
+var 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
+]);
+var 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
+]);
+var 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
+]);
+var SYMBOLS_LOGIC = /* @__PURE__ */ new Set([
+  "\u039B",
+  // LOGIC - Lógica condicional
+  "\u2297"
+  // PARALLEL BLOCK - Bloco paralelo
+]);
+var SYMBOLS = /* @__PURE__ */ new Set([
+  ...SYMBOLS_STATE,
+  ...SYMBOLS_EXEC,
+  ...SYMBOLS_STRUCT,
+  ...SYMBOLS_TIME,
+  ...SYMBOLS_ENERGY,
+  ...SYMBOLS_MEMORY,
+  ...SYMBOLS_UI,
+  ...SYMBOLS_SECURITY,
+  ...SYMBOLS_EVOLVE,
+  ...SYMBOLS_LOGIC
+]);
+var 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"
+};
+var OPERATORS = /* @__PURE__ */ new Set(["+", "\u2212", "-", "\u2254"]);
 function isWhitespace(ch) {
   return ch === " " || ch === "	" || ch === "\r";
 }
@@ -194,217 +1098,6 @@ function tokenize(input) {
   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) {
@@ -988,10 +1681,10 @@ function parseTokens(tokens, options) {
           }
           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 });
+        const substate2 = { type: "substate", name, props };
+        ast.substates.push(substate2);
+        ast.nodes.push(substate2);
+        onLog({ level: "info", event: "parse.substate", detail: substate2 });
         continue;
       }
       if (sym === "\u25CB") {
@@ -1700,19 +2393,8 @@ 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;
@@ -1744,614 +2426,151 @@ function parse(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)");
+// src/semantic/validate.ts
+init_cjs_shims();
+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) {
-    parts.push(isESM ? `export const SYSTEM = ${JSON.stringify(ast.system)};` : `const SYSTEM = ${JSON.stringify(ast.system)};
-module.exports.SYSTEM = SYSTEM;`);
+    pillars.state = true;
+  } else {
+    warnings.push("No \u03A3 SYSTEM declared - consider adding a system name");
   }
-  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.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.ui) {
-    parts.push(isESM ? `export const UI = ${JSON.stringify(ast.ui)};` : `const UI = ${JSON.stringify(ast.ui)};
-module.exports.UI = UI;`);
+  if (ast.functions.length > 0) {
+    pillars.action = true;
   }
-  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 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 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 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 } });
       }
     }
   }
-  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};`);
-    }
+  if (ast.objects?.length || ast.classes?.length) {
+    pillars.form = true;
   }
-  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};`);
+  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}'`);
+      }
     }
   }
-  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.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.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?.length || ast.causes?.length || ast.loops?.length) {
+    pillars.time = true;
   }
-  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.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.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.throttles?.length || ast.boosts?.length || ast.costs?.length) {
+    pillars.energy = true;
   }
-  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.throttles?.length) {
+    for (const t of ast.throttles) {
+      if (t.limit <= 0) {
+        errors.push(`Throttle '${t.target}' has invalid limit: ${t.limit}`);
+      }
     }
   }
-  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.memories?.length || ast.persists?.length || ast.database) {
+    pillars.memory = true;
   }
-  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?.length || ast.inputs?.length || ast.visuals?.length || ast.interfaces?.length) {
+    pillars.interface = true;
   }
-  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.securities?.length || ast.keys?.length || ast.sandboxes?.length) {
+    pillars.security = true;
   }
-  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>;`);
+  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.build) {
-    lines.push(`export declare const BUILD_TARGETS: string[];`);
-  }
-  if (ast.evolve) {
-    lines.push(`export declare const EVOLVE_STEPS: string[];`);
+  if (ast.evolve?.steps?.length) {
+    pillars.evolve = true;
   }
-  lines.push("");
-  lines.push("declare const _default: { SYSTEM: string; MODE: string; UI: string };");
-  lines.push("export default _default;");
-  return lines.join("\n");
+  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 };
 }
-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: [] };
+
+// src/evolve/stub.ts
+init_cjs_shims();
+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;
@@ -2514,72 +2733,425 @@ function applyEvolve(ast, options) {
         }
         break;
     }
-    if (applied) {
-      changed = true;
-      appliedSteps.push(step);
-    } else {
-      skippedSteps.push(step);
+    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/types.ts
+init_cjs_shims();
+
+// src/transpile.ts
+init_cjs_shims();
+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 (changed && onLog) {
-    onLog({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", event: "evolve.summary", detail: { appliedSteps, skippedSteps } });
+  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} };`);
+    }
   }
-  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 (ast.forms && ast.forms.length) {
+    for (const f of ast.forms) {
+      lines.push(`export declare const FORM_${f.name}: Record<string, any>;`);
     }
-    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);
+  }
+  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>;`);
     }
-    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);
-    };
+  if (ast.build) {
+    lines.push(`export declare const BUILD_TARGETS: string[];`);
   }
-  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 } });
+  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("");
     }
-  } 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) } });
+  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("");
     }
   }
-  ast.isEny = true;
-  return ast;
+  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"
+  );
 }
-
-// src/index.ts
-init_parser();
-init_tokenize();
-init_transpile();
 
 // src/ia/index.ts
+init_cjs_shims();
 var LocalIA = class {
   constructor() {
     this.name = "LocalIA";
@@ -2717,6 +3289,7 @@ async function processIA(ia, context, provider) {
 }
 
 // src/symbols.ts
+init_cjs_shims();
 var TRUE = true;
 var FALSE = false;
 var VOID = null;
@@ -2931,292 +3504,236 @@ var ALPHABET = {
   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}`;
+// src/index.ts
+init_runtime();
+
+// src/react/hooks.tsx
+init_cjs_shims();
+var import_react = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function useEnyState(initialValue) {
+  const [value, setValue] = (0, import_react.useState)(initialValue);
+  return [value, setValue];
 }
-function getEnergy(ast) {
-  return {
-    throttles: ast.throttles || [],
-    boosts: ast.boosts || [],
-    costs: ast.costs || []
-  };
+function useEnyEffect(effect2, deps) {
+  (0, import_react.useEffect)(effect2, deps);
 }
-function createMemory(name, size, persist = false) {
-  return `\u{1D4DC} ${name} ${size}${persist ? " persist" : ""}`;
+function useEnyFetch(url) {
+  const [data, setData] = (0, import_react.useState)(null);
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  const [error2, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    fetch(url).then((res) => res.json()).then((data2) => {
+      setData(data2);
+      setLoading(false);
+    }).catch((err) => {
+      setError(err);
+      setLoading(false);
+    });
+  }, [url]);
+  return [data, loading, error2];
 }
-function createPersist(target, storage = "db") {
-  return `\u267E ${target} ${storage}`;
+function usePersistentState(key, initialValue) {
+  const [value, setValue] = (0, import_react.useState)(() => {
+    const stored = localStorage.getItem(key);
+    return stored ? JSON.parse(stored) : initialValue;
+  });
+  const setPersistentValue = (0, import_react.useCallback)((newValue) => {
+    setValue(newValue);
+    localStorage.setItem(key, JSON.stringify(newValue));
+  }, [key]);
+  return [value, setPersistentValue];
 }
-function getMemory(ast) {
-  return {
-    database: ast.database,
-    memories: ast.memories || [],
-    persists: ast.persists || []
-  };
+function useMemoWithDeps(fn2, deps) {
+  return (0, import_react.useMemo)(fn2, deps);
 }
-function createInput(name, type = "text") {
-  return `\u2328 ${name} ${type}`;
+function useCallbackWithDeps(fn2, deps) {
+  return (0, import_react.useCallback)(fn2, deps);
 }
-function createVisual(name, props) {
-  const propsStr = Object.entries(props).map(([k, v]) => `  ${k}: ${v}`).join("\n");
-  return `\u{1F441} ${name} {
-${propsStr}
-}`;
+function useReducerWithState(reducer, initialState) {
+  return (0, import_react.useReducer)(reducer, initialState);
 }
-function getInterface(ast) {
+function useNavigation() {
   return {
-    forms: ast.forms || [],
-    inputs: ast.inputs || [],
-    visuals: ast.visuals || [],
-    interfaces: ast.interfaces || []
+    navigate: (path) => window.location.href = path,
+    back: () => window.history.back(),
+    forward: () => window.history.forward(),
+    reload: () => window.location.reload()
   };
 }
-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) {
+function useLogger() {
   return {
-    securities: ast.securities || [],
-    keys: ast.keys || [],
-    sandboxes: ast.sandboxes || [],
-    locks: ast.locks || [],
-    unlocks: ast.unlocks || []
+    info: (msg, data) => console.log(`\u2139\uFE0F ${msg}`, data),
+    error: (msg, data) => console.error(`\u274C ${msg}`, data),
+    warn: (msg, data) => console.warn(`\u26A0\uFE0F ${msg}`, data)
   };
 }
-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 || []
+var EnyUI = {
+  /**
+   * EnyUI.card - Card component
+   */
+  card: ({ children, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: `bg-white rounded-lg shadow-lg p-6 ${className}`, children }),
+  /**
+   * EnyUI.btn - Button component
+   */
+  btn: ({
+    children,
+    onClick,
+    type = "primary",
+    className = ""
+  }) => {
+    const baseClass = "px-4 py-2 rounded-lg font-bold transition";
+    const typeClass = {
+      primary: "bg-blue-600 text-white hover:bg-blue-700",
+      danger: "bg-red-600 text-white hover:bg-red-700",
+      secondary: "bg-gray-300 text-black hover:bg-gray-400"
+    }[type];
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { className: `${baseClass} ${typeClass} ${className}`, onClick, children });
+  },
+  /**
+   * EnyUI.input - Input component
+   */
+  input: ({
+    value,
+    onChange,
+    placeholder = "",
+    type = "text",
+    className = ""
+  }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "input",
+    {
+      type,
+      value,
+      onChange: (e) => onChange(e.target.value),
+      placeholder,
+      className: `w-full px-4 py-2 border rounded-lg focus:outline-none focus:border-blue-600 ${className}`
+    }
+  ),
+  /**
+   * EnyUI.grid - Grid component
+   */
+  grid: ({ children, cols = 1, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: `grid grid-cols-${cols} gap-4 ${className}`, children }),
+  /**
+   * EnyUI.flex - Flexbox component
+   */
+  flex: ({ children, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: `flex ${className}`, children }),
+  /**
+   * EnyUI.text - Text component
+   */
+  text: ({ children, size = "base", className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: `text-${size} ${className}`, children }),
+  /**
+   * EnyUI.heading - Heading component
+   */
+  h1: ({ children, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h1", { className: `text-4xl font-bold ${className}`, children }),
+  h2: ({ children, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", { className: `text-3xl font-bold ${className}`, children }),
+  h3: ({ children, className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { className: `text-2xl font-bold ${className}`, children }),
+  /**
+   * EnyUI.modal - Modal component
+   */
+  modal: ({
+    isOpen,
+    onClose,
+    children,
+    title = ""
+  }) => {
+    if (!isOpen) return null;
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "bg-white rounded-lg p-8 max-w-md w-full", children: [
+      title && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h2", { className: "text-2xl font-bold mb-4", children: title }),
+      children,
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "button",
+        {
+          onClick: onClose,
+          className: "mt-4 w-full bg-gray-300 text-black py-2 rounded-lg hover:bg-gray-400",
+          children: "Fechar"
+        }
+      )
+    ] }) });
+  },
+  /**
+   * EnyUI.spinner - Loading spinner
+   */
+  spinner: ({ className = "" } = {}) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: `animate-spin inline-block w-6 h-6 border-4 border-blue-600 border-t-transparent rounded-full ${className}` }),
+  /**
+   * EnyUI.badge - Badge component
+   */
+  badge: ({ children, color = "blue", className = "" }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `px-3 py-1 rounded-full text-white bg-${color}-600 ${className}`, children })
+};
+var EnyContext = {
+  create: (initialValue) => import_react.default.createContext(initialValue),
+  use: (context) => (0, import_react.useContext)(context)
+};
+var EnyValidate = {
+  email: (str) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str),
+  min: (len) => (str) => str.length >= len,
+  max: (len) => (str) => str.length <= len,
+  required: (val) => val != null && val !== "",
+  pattern: (regex) => (val) => regex.test(val),
+  equals: (expected) => (val) => val === expected
+};
+function useValidation(schema) {
+  return (data) => {
+    const errors = {};
+    for (const [key, validator] of Object.entries(schema)) {
+      if (!validator(data[key])) {
+        errors[key] = true;
+      }
+    }
+    return errors;
   };
 }
-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);
+init_firebase();
+function createEnySystem() {
+  return new (init_runtime(), __toCommonJS(runtime_exports)).ENYRuntime();
 }
-function isValidENY(code) {
-  try {
-    const { parse: parse2 } = (init_parser(), __toCommonJS(parser_exports));
-    const ast = parse2(code);
-    return ast.isEny === true;
-  } catch {
-    return false;
-  }
+function initializeEnyFirebase(config) {
+  return new (init_firebase(), __toCommonJS(firebase_exports)).ENYFirebase().initialize(config);
 }
+var VERSION = "2.0.0";
+var NAME = "eny-ai";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALPHABET,
-  EVOLVE,
+  ENYFirebase,
+  ENYRuntime,
+  EnyContext,
+  EnyUI,
+  EnyValidate,
   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,
+  createEnySystem,
   defaultIAManager,
   effect,
   error,
   filter,
   find,
+  firebase,
   fn,
-  generateENY,
   get,
-  getEnergy,
-  getEvolve,
-  getFunctions,
-  getInterface,
-  getMemory,
-  getSecurity,
-  getState,
-  getStructures,
-  getTemporals,
   hasWASMTarget,
-  isValidENY,
+  initializeEnyFirebase,
   log,
   map,
   navigate,
   parse,
   post,
   processIA,
-  quickSystem,
   reduce,
   runENY,
   shape,
@@ -3229,6 +3746,19 @@ function isValidENY(code) {
   transpileToDTS,
   transpileToJS,
   transpileToWAT,
+  useAuth,
+  useCallbackWithDeps,
+  useEnyEffect,
+  useEnyFetch,
+  useEnyState,
+  useFirebase,
+  useLogger,
+  useMemoWithDeps,
+  useNavigation,
+  usePersistentState,
+  useRealtimeData,
+  useReducerWithState,
+  useValidation,
   validate,
   validateSemantic,
   validateSemanticFull