@hyperfixi/vite-plugin 3.3.0 → 4.0.0

package/dist/index.cjs

@@ -35,7 +35,6 @@ __export(index_exports, {
   REGIONS: () => REGIONS,
   SUPPORTED_LANGUAGES: () => SUPPORTED_LANGUAGES,
   clearCustomKeywords: () => clearCustomKeywords,
-  clearSemanticParser: () => clearSemanticParser,
   computeUsageHash: () => computeUsageHash,
   default: () => index_default,
   descriptorToScanRule: () => descriptorToScanRule,
@@ -43,16 +42,76 @@ __export(index_exports, {
   getAllLanguageCodes: () => getAllLanguageCodes,
   getKeywordsForLanguage: () => getKeywordsForLanguage,
   getOptimalRegion: () => getOptimalRegion,
-  hasSemanticParser: () => hasSemanticParser,
   hyperfixi: () => hyperfixi,
   isNonLatinLanguage: () => isNonLatinLanguage,
-  registerCustomKeywords: () => registerCustomKeywords,
-  setSemanticParser: () => setSemanticParser
+  registerCustomKeywords: () => registerCustomKeywords
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/scanner.ts
-var import_bundle_generator = require("@hyperfixi/core/bundle-generator");
+// src/engine-modules.ts
+var engine = __toESM(require("@hyperfixi/engine"), 1);
+var import_engine = require("@hyperfixi/engine");
+function exportNameOf(mod) {
+  for (const [name, value] of Object.entries(engine)) {
+    if (value === mod) return name;
+  }
+  throw new Error("[hyperfixi] an engine module in `everything` is not a named export");
+}
+var ENGINE_MODULES = import_engine.everything.map((mod) => {
+  const grammar = (0, import_engine.createGrammar)();
+  mod(grammar);
+  return {
+    name: exportNameOf(mod),
+    // The template text line registers under a keyword no identifier can be
+    // spelled as (`#text`); it is not something a scan can find.
+    commands: Object.keys(grammar.commands).filter((k) => /^[a-z]+$/.test(k)),
+    features: Object.keys(grammar.features)
+  };
+});
+var byName = new Map(ENGINE_MODULES.map((m) => [m.name, m]));
+var COMMAND_KEYWORDS = new Map(
+  ENGINE_MODULES.flatMap((m) => m.commands.map((k) => [k, m.name]))
+);
+var FEATURE_KEYWORDS = new Map(
+  ENGINE_MODULES.flatMap((m) => m.features.map((k) => [k, m.name]))
+);
+var NOT_SCANNED = /* @__PURE__ */ new Set(["on", "if", "live", "when", "bind"]);
+var SCANNABLE_KEYWORDS = [
+  .../* @__PURE__ */ new Set([...COMMAND_KEYWORDS.keys(), ...FEATURE_KEYWORDS.keys()])
+].filter((k) => !NOT_SCANNED.has(k)).sort();
+var BLOCK_MODULES = {
+  if: ["ifCommand"],
+  repeat: ["repeat", "loopControl"],
+  for: ["repeat", "loopControl"],
+  while: ["repeat", "loopControl"],
+  fetch: ["fetchCommand"]
+};
+var ALWAYS = ["on", "conversions"];
+function resolveModules(usage) {
+  const wanted = new Set(ALWAYS);
+  const unknown = [];
+  for (const name of usage.commands) {
+    const mod = COMMAND_KEYWORDS.get(name) ?? FEATURE_KEYWORDS.get(name);
+    if (mod) wanted.add(mod);
+    else if (!(name in BLOCK_MODULES)) unknown.push(name);
+  }
+  for (const block of usage.blocks) {
+    for (const mod of BLOCK_MODULES[block] ?? []) wanted.add(mod);
+  }
+  if (usage.positional) wanted.add("expressionsExtra");
+  if (usage.reactivity) {
+    wanted.add("reactivity");
+    wanted.add("liveTemplates");
+  }
+  if (usage.construct) wanted.add("construct");
+  if (usage.cookies) wanted.add("cookies");
+  if (wanted.has("toggle")) wanted.add("toggleElement");
+  const modules = ENGINE_MODULES.filter((m) => wanted.has(m.name)).map((m) => m.name);
+  for (const name of wanted) {
+    if (!byName.has(name)) throw new Error(`[hyperfixi] no engine module named ${name}`);
+  }
+  return { modules, unknown: [...new Set(unknown)].sort() };
+}
 
 // src/language-keywords.ts
 var SUPPORTED_LANGUAGES = [
@@ -1089,17 +1148,7 @@ var SSE_NS_PATTERN = /\bsse-[\w\-\p{L}]+\s*=\s*["']/u;
 var WS_NS_PATTERN = /\bws-[\w\-\p{L}]+\s*=\s*["']/u;
 
 // src/scanner.ts
-var SCANNABLE_COMMANDS = [
-  .../* @__PURE__ */ new Set([...import_bundle_generator.AVAILABLE_COMMANDS, ...import_bundle_generator.FULL_RUNTIME_ONLY_COMMANDS])
-].filter(
-  (cmd) => /^[A-Za-z]+$/.test(cmd) && // `unless` is handled by the block detection below (it compiles to the
-  // lite-capable `if` block — flagging it as a full-runtime-only COMMAND
-  // would needlessly bump every unless-user to a full-runtime bundle).
-  // `bind` is handled by the dedicated reactivity detection below, which
-  // routes to the hx-v4 bundle (the tier that actually ships reactivity).
-  cmd !== "unless" && cmd !== "bind"
-);
-var COMMAND_PATTERN_SOURCE = `\\b(${SCANNABLE_COMMANDS.join("|")})\\b`;
+var COMMAND_PATTERN_SOURCE = `\\b(${SCANNABLE_KEYWORDS.join("|")})\\b`;
 var HTMX_REQUEST_PATTERN = /\b(hx-get|hx-post|hx-put|hx-patch|hx-delete)\s*=\s*["']([^"']+)["']/gi;
 var FIXI_ACTION_PATTERN = /\bfx-action\s*=\s*["']([^"']+)["']/gi;
 var FIXI_METHOD_PATTERN = /\bfx-method\s*=\s*["'](GET|POST|PUT|PATCH|DELETE)["']/gi;
@@ -1151,7 +1200,9 @@ var Scanner = class {
       positional: false,
       detectedLanguages: /* @__PURE__ */ new Set(),
       needsReactivity: false,
-      needsBindToProperty: false
+      needsBindToProperty: false,
+      needsConstruct: false,
+      needsCookies: false
     };
     const attrPatterns = [
       /_\s*=\s*"([^"]+)"/g,
@@ -1219,9 +1270,11 @@ var Scanner = class {
     if (/\bfor\s+(each|every)\b/i.test(script)) usage.blocks.add("for");
     if (/\bwhile\b/.test(script)) usage.blocks.add("while");
     if (/\bfetch\b/.test(script)) usage.blocks.add("fetch");
-    if (/\b(first|last|next|previous|closest|parent)\b/.test(script)) {
+    if (/\b(first|last|next|previous|closest|parent|random)\b/.test(script) || /\b(where|sorted\s+by|mapped\s+to|split\s+by|joined\s+by|some|beep!)/.test(script)) {
       usage.positional = true;
     }
+    if (/\bnew\s+[A-Z$_][\w$.]*\s*\(/.test(script)) usage.needsConstruct = true;
+    if (/\bcookies\b/.test(script)) usage.needsCookies = true;
     const languages = detectLanguages(script);
     for (const lang of languages) {
       usage.detectedLanguages.add(lang);
@@ -1416,7 +1469,8 @@ var Aggregator = class {
       const positionalEqual = existing.positional === usage.positional;
       const languagesEqual = this.setsEqual(existing.detectedLanguages, usage.detectedLanguages);
       const htmxEqual = this.htmxUsageEqual(existing.htmx, usage.htmx);
-      if (commandsEqual && blocksEqual && positionalEqual && languagesEqual && htmxEqual) {
+      const flagsEqual = !!existing.needsReactivity === !!usage.needsReactivity && !!existing.needsBindToProperty === !!usage.needsBindToProperty && !!existing.needsConstruct === !!usage.needsConstruct && !!existing.needsCookies === !!usage.needsCookies;
+      if (commandsEqual && blocksEqual && positionalEqual && languagesEqual && htmxEqual && flagsEqual) {
         return false;
       }
     }
@@ -1464,6 +1518,8 @@ var Aggregator = class {
     };
     let needsReactivity = false;
     let needsBindToProperty = false;
+    let needsConstruct = false;
+    let needsCookies = false;
     for (const usage of this.fileUsage.values()) {
       for (const cmd of usage.commands) commands.add(cmd);
       for (const block of usage.blocks) blocks.add(block);
@@ -1471,6 +1527,8 @@ var Aggregator = class {
       if (usage.positional) positional = true;
       if (usage.needsReactivity) needsReactivity = true;
       if (usage.needsBindToProperty) needsBindToProperty = true;
+      if (usage.needsConstruct) needsConstruct = true;
+      if (usage.needsCookies) needsCookies = true;
       if (usage.htmx) {
         if (usage.htmx.hasHtmxAttributes) htmx.hasHtmxAttributes = true;
         if (usage.htmx.hasFixiAttributes) htmx.hasFixiAttributes = true;
@@ -1499,6 +1557,8 @@ var Aggregator = class {
       htmx,
       needsReactivity,
       needsBindToProperty,
+      needsConstruct,
+      needsCookies,
       fileUsage: new Map(this.fileUsage)
     };
     return this.cachedUsage;
@@ -1553,9 +1613,9 @@ var Aggregator = class {
   htmxUsageEqual(a, b) {
     if (!a && !b) return true;
     if (!a || !b) return false;
-    return a.hasHtmxAttributes === b.hasHtmxAttributes && a.hasFixiAttributes === b.hasFixiAttributes && this.setsEqual(a.httpMethods, b.httpMethods) && this.setsEqual(a.swapStrategies, b.swapStrategies) && this.setsEqual(a.triggerModifiers, b.triggerModifiers) && this.setsEqual(a.urlManagement, b.urlManagement) && a.usesConfirm === b.usesConfirm && !!a.needsSwapTiming === !!b.needsSwapTiming && // htmx v4 / reactivity flags: these drive selection of the hx-v4 tier,
-    // so a change must count as "usage changed" or HMR serves a stale
-    // bundle. They were omitted when the v4 surface landed (#623).
+    return a.hasHtmxAttributes === b.hasHtmxAttributes && a.hasFixiAttributes === b.hasFixiAttributes && this.setsEqual(a.httpMethods, b.httpMethods) && this.setsEqual(a.swapStrategies, b.swapStrategies) && this.setsEqual(a.triggerModifiers, b.triggerModifiers) && this.setsEqual(a.urlManagement, b.urlManagement) && a.usesConfirm === b.usesConfirm && !!a.needsSwapTiming === !!b.needsSwapTiming && // htmx / reactivity flags: these decide which engine modules the bundle
+    // registers, so a change must count as "usage changed" or HMR serves a
+    // stale bundle. They were omitted when the v4 surface landed (#623).
     !!a.needsHxLive === !!b.needsHxLive && !!a.needsSSE === !!b.needsSSE && !!a.needsWS === !!b.needsWS && !!a.needsBindToProperty === !!b.needsBindToProperty && !!a.needsReactivity === !!b.needsReactivity && this.arraysEqual(a.onHandlers, b.onHandlers);
   }
   arraysEqual(a, b) {
@@ -1565,225 +1625,7 @@ var Aggregator = class {
   }
 };
 
-// src/generator.ts
-var import_bundle_generator2 = require("@hyperfixi/core/bundle-generator");
-
 // src/semantic-integration.ts
-var MULTILINGUAL_COMMAND_ALIASES = {
-  ja: {
-    \u30C8\u30B0\u30EB: "toggle",
-    \u5207\u308A\u66FF\u3048: "toggle",
-    \u8FFD\u52A0: "add",
-    \u524A\u9664: "remove",
-    \u8868\u793A: "show",
-    \u96A0\u3059: "hide",
-    \u975E\u8868\u793A: "hide",
-    \u8A2D\u5B9A: "set",
-    \u30BB\u30C3\u30C8: "set",
-    \u5897\u52A0: "increment",
-    \u6E1B\u5C11: "decrement",
-    \u30ED\u30B0: "log",
-    \u51FA\u529B: "log"
-  },
-  ko: {
-    \uD1A0\uAE00: "toggle",
-    \uC804\uD658: "toggle",
-    \uCD94\uAC00: "add",
-    \uC81C\uAC70: "remove",
-    \uC0AD\uC81C: "remove",
-    \uD45C\uC2DC: "show",
-    \uC228\uAE30\uB2E4: "hide",
-    \uC124\uC815: "set",
-    \uC99D\uAC00: "increment",
-    \uAC10\uC18C: "decrement",
-    \uB85C\uADF8: "log"
-  },
-  zh: {
-    \u5207\u6362: "toggle",
-    \u6DFB\u52A0: "add",
-    \u79FB\u9664: "remove",
-    \u5220\u9664: "remove",
-    \u663E\u793A: "show",
-    \u9690\u85CF: "hide",
-    \u8BBE\u7F6E: "set",
-    \u8BBE\u5B9A: "set",
-    \u589E\u52A0: "increment",
-    \u51CF\u5C11: "decrement",
-    \u65E5\u5FD7: "log",
-    \u8BB0\u5F55: "log"
-  },
-  ar: {
-    \u0628\u062F\u0651\u0644: "toggle",
-    \u0628\u062F\u0644: "toggle",
-    \u0623\u0636\u0641: "add",
-    \u0627\u0636\u0641: "add",
-    \u0623\u0632\u0644: "remove",
-    \u0627\u0632\u0644: "remove",
-    \u0627\u062D\u0630\u0641: "remove",
-    \u0623\u0638\u0647\u0631: "show",
-    \u0627\u0638\u0647\u0631: "show",
-    \u0623\u062E\u0641\u0650: "hide",
-    \u0627\u062E\u0641: "hide",
-    \u0636\u0639: "set",
-    \u0627\u0636\u0639: "set",
-    \u0632\u0650\u062F: "increment",
-    \u0623\u0646\u0642\u0635: "decrement"
-  },
-  es: {
-    alternar: "toggle",
-    a\u00F1adir: "add",
-    agregar: "add",
-    quitar: "remove",
-    eliminar: "remove",
-    mostrar: "show",
-    ocultar: "hide",
-    esconder: "hide",
-    establecer: "set",
-    fijar: "set",
-    incrementar: "increment",
-    decrementar: "decrement"
-  },
-  pt: {
-    alternar: "toggle",
-    adicionar: "add",
-    remover: "remove",
-    mostrar: "show",
-    esconder: "hide",
-    ocultar: "hide",
-    definir: "set",
-    incrementar: "increment",
-    decrementar: "decrement"
-  },
-  fr: {
-    basculer: "toggle",
-    ajouter: "add",
-    supprimer: "remove",
-    retirer: "remove",
-    afficher: "show",
-    montrer: "show",
-    cacher: "hide",
-    masquer: "hide",
-    d\u00E9finir: "set",
-    incr\u00E9menter: "increment",
-    d\u00E9cr\u00E9menter: "decrement"
-  },
-  de: {
-    umschalten: "toggle",
-    hinzuf\u00FCgen: "add",
-    entfernen: "remove",
-    l\u00F6schen: "remove",
-    anzeigen: "show",
-    zeigen: "show",
-    verbergen: "hide",
-    verstecken: "hide",
-    setzen: "set",
-    festlegen: "set",
-    erh\u00F6hen: "increment",
-    verringern: "decrement"
-  },
-  tr: {
-    de\u011Fi\u015Ftir: "toggle",
-    de\u011Fistir: "toggle",
-    ekle: "add",
-    kald\u0131r: "remove",
-    kaldir: "remove",
-    sil: "remove",
-    g\u00F6ster: "show",
-    gizle: "hide",
-    sakla: "hide",
-    ayarla: "set",
-    belirle: "set",
-    artt\u0131r: "increment",
-    azalt: "decrement"
-  },
-  id: {
-    alih: "toggle",
-    beralih: "toggle",
-    tambah: "add",
-    hapus: "remove",
-    buang: "remove",
-    tampilkan: "show",
-    sembunyikan: "hide",
-    atur: "set",
-    tetapkan: "set",
-    tambahkan: "increment",
-    kurangi: "decrement"
-  },
-  sw: {
-    badilisha: "toggle",
-    ongeza: "add",
-    ondoa: "remove",
-    futa: "remove",
-    onyesha: "show",
-    ficha: "hide",
-    weka: "set",
-    sanidi: "set",
-    ongezea: "increment",
-    punguza: "decrement"
-  },
-  qu: {
-    tikray: "toggle",
-    yapay: "add",
-    qichuy: "remove",
-    pichay: "remove",
-    rikuchiy: "show",
-    pakay: "hide",
-    churay: "set",
-    pisiyachiy: "decrement"
-  }
-};
-function getMultilingualCommandAliases(languages) {
-  const aliases = {};
-  for (const lang of languages) {
-    const langAliases = MULTILINGUAL_COMMAND_ALIASES[lang];
-    if (langAliases) {
-      Object.assign(aliases, langAliases);
-    }
-  }
-  return aliases;
-}
-function generateMultilingualAliases(languages) {
-  const aliases = {};
-  for (const lang of languages) {
-    const langAliases = MULTILINGUAL_COMMAND_ALIASES[lang];
-    if (langAliases) {
-      Object.assign(aliases, langAliases);
-    }
-  }
-  if (Object.keys(aliases).length === 0) {
-    return `
-// No multilingual aliases needed - just pass through
-function preprocessMultilingual(code) { return code; }
-`;
-  }
-  const aliasEntries = Object.entries(aliases).map(([key, val]) => `  '${key}': '${val}'`).join(",\n");
-  const escapedKeys = Object.keys(aliases).map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-  return `
-// Multilingual command aliases for HybridParser fallback
-const MULTILINGUAL_ALIASES = {
-${aliasEntries}
-};
-
-// Register multilingual aliases with the parser
-addCommandAliases(MULTILINGUAL_ALIASES);
-
-// Preprocessing regex to translate multilingual keywords to English
-// The HybridParser tokenizer only accepts ASCII identifiers, so we need
-// to translate non-ASCII keywords before parsing.
-const MULTILINGUAL_KEYWORD_REGEX = new RegExp('(^|\\\\s)(${escapedKeys})(?=\\\\s|\\\\.|$)', 'g');
-
-/**
- * Preprocess multilingual code to replace non-ASCII keywords with English equivalents.
- * This is needed because HybridParser's tokenizer only accepts ASCII identifiers.
- */
-function preprocessMultilingual(code) {
-  return code.replace(MULTILINGUAL_KEYWORD_REGEX, (match, prefix, keyword) => {
-    const english = MULTILINGUAL_ALIASES[keyword];
-    return english ? prefix + english : match;
-  });
-}
-`;
-}
 function resolveSemanticConfig(options, detectedLanguages) {
   const grammarEnabled = options.grammar ?? false;
   let semanticEnabled = grammarEnabled;
@@ -1999,15 +1841,11 @@ function generateSemanticIntegrationCode(config) {
   const languages = [...config.languages].join("', '");
   let code = `
 // =============================================================================
-// SEMANTIC PARSER INTEGRATION
+// MULTILINGUAL (semantic) \u2014 translated as read; the attribute stays as written
 // =============================================================================
 
 // Core infrastructure (no language data bundled)
-import {
-  parseWithConfidence,
-  buildAST,
-  isLanguageSupported,
-} from '@lokascript/semantic/core';
+import { parseWithConfidence, render, isLanguageRegistered } from '@lokascript/semantic/core';
 
 // Register required languages (self-registering side-effect imports)
 `;
@@ -2021,58 +1859,36 @@ import {
 import { translate } from '@lokascript/semantic/core';
 `;
   }
-  const aliasesCode = generateMultilingualAliases(config.languages);
   code += `
 const SUPPORTED_SEMANTIC_LANGUAGES = ['${languages}', 'en'];
 const SEMANTIC_CONFIDENCE_THRESHOLD = 0.7;
 
-${aliasesCode}
+/** The element's language: data-lang, data-hyperscript-lang, the lang cascade, the document's. */
+function resolveLanguage(elt) {
+  const code =
+    elt.getAttribute('data-lang') ||
+    elt.closest?.('[data-hyperscript-lang]')?.getAttribute('data-hyperscript-lang') ||
+    elt.closest?.('[lang]')?.getAttribute('lang') ||
+    (typeof document !== 'undefined' ? document.documentElement?.lang : null);
+  return code ? code.toLowerCase().split(/[-_]/)[0] : null;
+}
 
 /**
- * Parse hyperscript using semantic parser with auto-language detection.
- * Tries each supported language until one returns a high-confidence result.
- * Falls back to HybridParser if none match.
- *
- * @param code - The hyperscript code to parse
- * @param lang - Optional language hint. If provided, tries this language first.
+ * The engine's source transform: the English for a non-English script, or null
+ * to leave the script as written (English, an unregistered language, a parse
+ * below the confidence threshold, or a render that changed nothing).
  */
-function parseWithSemantic(code, lang = null) {
-  // Determine languages to try: specified lang first, then others
-  let languagesToTry = [...SUPPORTED_SEMANTIC_LANGUAGES];
-  if (lang && !languagesToTry.includes(lang)) {
-    languagesToTry.unshift(lang);
-  } else if (lang) {
-    // Move specified lang to front
-    languagesToTry = [lang, ...languagesToTry.filter(l => l !== lang)];
-  }
-
-  // Try each language until one succeeds
-  for (const tryLang of languagesToTry) {
-    if (!isLanguageSupported(tryLang)) continue;
-    try {
-      const result = parseWithConfidence(code, tryLang);
-      if (result && result.confidence >= SEMANTIC_CONFIDENCE_THRESHOLD) {
-        // buildAST returns {ast, warnings} - extract the ast
-        const buildResult = buildAST(result.node);
-        const ast = buildResult.ast;
-
-        // Semantic parser doesn't fully handle event handlers - fallback to HybridParser
-        // Event handlers like "on click toggle .active" produce incomplete AST
-        if (ast && ast.type === 'command' && ast.name === 'on') {
-          break; // Fallback to HybridParser
-        }
-
-        return ast;
-      }
-    } catch (e) {
-      // Continue trying other languages
-    }
+function translateSource(src, elt) {
+  const lang = elt ? resolveLanguage(elt) : null;
+  if (!lang || lang === 'en' || !isLanguageRegistered(lang)) return null;
+  try {
+    const result = parseWithConfidence(src, lang);
+    if (!result || !result.node || result.confidence < SEMANTIC_CONFIDENCE_THRESHOLD) return null;
+    const english = render(result.node, 'en');
+    return english && english !== src ? english : null;
+  } catch {
+    return null;
   }
-
-  // Fallback to HybridParser for event handlers and unrecognized patterns
-  // Preprocess to translate non-ASCII keywords to English (tokenizer only accepts ASCII)
-  const preprocessedCode = preprocessMultilingual(code);
-  return new HybridParser(preprocessedCode).parse();
 }
 `;
   if (config.grammarEnabled) {
@@ -2082,9 +1898,7 @@ function parseWithSemantic(code, lang = null) {
  *
  * Returns the input UNCHANGED when it cannot be parsed in \`fromLang\`, or when
  * \`toLang\` is not one of the languages this bundle registered. The semantic
- * translator throws in both cases; the i18n one this replaced never did \u2014 it
- * degraded to word substitution, which turned unparseable input into plausible
- * nonsense. Returning the source is the honest degradation.
+ * translator throws in both cases; returning the source is the honest degradation.
  */
 function translateHyperscript(code, fromLang, toLang) {
   try {
@@ -2100,7 +1914,7 @@ function translateHyperscript(code, fromLang, toLang) {
 function getSemanticExports(config) {
   const exports2 = [];
   if (config.enabled) {
-    exports2.push("parseWithSemantic");
+    exports2.push("translateSource");
     exports2.push("SUPPORTED_SEMANTIC_LANGUAGES");
   }
   if (config.grammarEnabled) {
@@ -2110,421 +1924,77 @@ function getSemanticExports(config) {
 }
 
 // src/generator.ts
-function stripTypes(code) {
-  return code.replace(/\s+as\s+\w+<[^>]*(?:<[^>]*>[^>]*)*>/g, "").replace(/\s+as\s+\w+(?:\[\])?/g, "").replace(/:\s*\w+<[^>]*(?:<[^>]*>[^>]*)*>(?:\[\])?(?=\s*[=;,)\]])/g, "").replace(
-    /:\s*(?:string|number|boolean|any|unknown|void|never|null|undefined|object|symbol|bigint)(?=\s*[=;,)\]])/g,
-    ""
-  ).replace(/:\s*[A-Z]\w*(?:\[\])?(?=\s*[=;,)\]])/g, "").replace(/\((\w+):\s*(?:\w+|unknown|any)\)/g, "($1)").replace(/Promise<[^>]+>/g, "Promise").replace(/Array<[^>]+>/g, "Array").replace(/\):\s*\w+(?:<[^>]*>)?(?:\[\])?\s*(?=[{=])/g, ") ").replace(/\):\s*\w+(?:<[^>]*>)?\s*=>/g, ") =>").replace(
-    /:\s*(?:TransitionEvent|MouseEvent|KeyboardEvent|Event|Element|HTMLElement|Node)(?=\s*[=;,)\]])/g,
-    ""
-  ).replace(/(\w)!(?=[,;)\].\s])/g, "$1");
-}
-var COMMAND_IMPLEMENTATIONS = {};
-var BLOCK_IMPLEMENTATIONS = {};
-for (const [name, code] of Object.entries(import_bundle_generator2.COMMAND_IMPLEMENTATIONS)) {
-  COMMAND_IMPLEMENTATIONS[name] = stripTypes(code);
-}
-for (const [name, code] of Object.entries(import_bundle_generator2.BLOCK_IMPLEMENTATIONS)) {
-  BLOCK_IMPLEMENTATIONS[name] = stripTypes(code);
-}
-function generateBundleCode(config) {
+var ENGINE_API_NAMES = ["api", "boot", "register"];
+function generateBundleCode(spec) {
   const {
     name,
+    modules,
     commands,
-    blocks = [],
-    htmxIntegration = false,
-    globalName = "hyperfixi",
-    positionalExpressions = false,
-    autoInit = true,
-    esModule = true,
-    parserType = "hybrid"
-  } = config;
-  const needsStyleHelpers = commands.some((cmd) => import_bundle_generator2.STYLE_COMMANDS.includes(cmd));
-  const needsElementArrayHelper = commands.some((cmd) => import_bundle_generator2.ELEMENT_ARRAY_COMMANDS.includes(cmd));
-  const needsMorphlex = commands.some((cmd) => import_bundle_generator2.MORPH_COMMANDS.includes(cmd));
-  const hasBlocks = blocks.length > 0;
-  const hasReturn = commands.includes("return");
-  const commandCases = commands.filter((cmd) => COMMAND_IMPLEMENTATIONS[cmd]).map((cmd) => COMMAND_IMPLEMENTATIONS[cmd]).join("\n");
-  const blockCases = blocks.filter((block) => BLOCK_IMPLEMENTATIONS[block]).map((block) => BLOCK_IMPLEMENTATIONS[block]).join("\n");
-  const parserTemplate = parserType === "lite" ? import_bundle_generator2.LITE_PARSER_TEMPLATE : import_bundle_generator2.HYBRID_PARSER_TEMPLATE;
-  const morphlexImport = needsMorphlex ? `import { morph as morphlexMorph, morphInner as morphlexMorphInner } from 'morphlex';
-
+    blocks,
+    positional,
+    reactivity,
+    htmxIntegration,
+    globalName,
+    autoInit,
+    esModule,
+    semantic
+  } = spec;
+  const semanticCode = generateSemanticIntegrationCode(semantic);
+  const semanticExports = getSemanticExports(semantic);
+  const languages = semantic.enabled ? [...semantic.languages].sort() : [];
+  const headerLines = [
+    `Modules: ${modules.join(", ")}`,
+    commands.length > 0 ? `Commands: ${commands.join(", ")}` : "",
+    blocks.length > 0 ? `Blocks: ${blocks.join(", ")}` : "",
+    positional ? "Expressions: positional / collection (expressionsExtra)" : "",
+    reactivity ? "Reactivity: live / when / bind" : "",
+    semantic.enabled ? `Multilingual: ${languages.join(", ") || "en"} (translated as read, through the engine's source transform)` : "",
+    htmxIntegration ? "htmx: content swapped in is processed (htmx:load / htmx:afterSettle)" : ""
+  ].filter(Boolean);
+  const bundleInfo = JSON.stringify({
+    generator: "@hyperfixi/vite-plugin",
+    modules,
+    commands,
+    blocks,
+    languages
+  });
+  const apiProps = [`bundle: ${bundleInfo}`, ...semanticExports].map((p) => `  ${p},`).join("\n");
+  const installGlobal = globalName === "_hyperscript" ? "" : `  window.${globalName} = api;
+`;
+  const htmxHooks = htmxIntegration ? `
+  // htmx (any major) announces swapped-in content on these; hand it to the engine.
+  for (const type of ['htmx:load', 'htmx:afterSettle']) {
+    document.addEventListener(type, event => {
+      const detail = event.detail;
+      const target = (detail && (detail.elt || detail.target)) || event.target;
+      if (target instanceof Element) api.processNode(target);
+    });
+  }
 ` : "";
   return `/**
- * LokaScript ${name} Bundle (Auto-Generated)
+ * hyperfixi ${name} bundle (auto-generated)
  *
  * Generated by: @hyperfixi/vite-plugin
- * Parser: ${parserType}
- * Commands: ${commands.join(", ")}${blocks.length > 0 ? `
- * Blocks: ${blocks.join(", ")}` : ""}${positionalExpressions ? "\n * Positional expressions: enabled" : ""}${needsMorphlex ? "\n * Morphing: morphlex (~2.5KB)" : ""}
+ * Engine: @hyperfixi/engine \u2014 the grammar is exactly the modules registered below.
+${headerLines.map((l) => ` * ${l}`).join("\n")}
  *
  * DO NOT EDIT - This file is automatically regenerated.
  */
 
-${morphlexImport}// Embedded ${parserType} parser (no external dependencies)
-${parserTemplate}
-
-// Runtime state
-const globalVars = new Map();
-${hasBlocks ? "const MAX_LOOP_ITERATIONS = 1000;" : ""}
-
-async function evaluate(node, ctx) {
-  switch (node.type) {
-    case 'literal': return node.value;
-
-    case 'identifier':
-      if (node.value === 'me' || node.value === 'my') return ctx.me;
-      if (node.value === 'it') return ctx.it;
-      if (node.value === 'you') return ctx.you;
-      if (node.value === 'event') return ctx.event;
-      if (node.value === 'body') return document.body;
-      if (node.value === 'document') return document;
-      if (node.value === 'window') return window;
-      if (ctx.locals.has(node.value)) return ctx.locals.get(node.value);
-      if (node.value in ctx.me) return ctx.me[node.value];
-      return node.value;
-
-    case 'contextReference':
-      // Semantic AST format for context references (me, you, it, etc.)
-      switch (node.contextType || node.name) {
-        case 'me': return ctx.me;
-        case 'it': return ctx.it;
-        case 'you': return ctx.you;
-        case 'event': return ctx.event;
-        case 'body': return document.body;
-        case 'document': return document;
-        case 'window': return window;
-        default: return ctx.me;
-      }
-
-    case 'variable':
-      if (node.scope === 'local') return ctx.locals.get(node.name.slice(1));
-      const gName = node.name.slice(1);
-      if (globalVars.has(gName)) return globalVars.get(gName);
-      return window[node.name];
-
-    case 'selector':
-      const elements = document.querySelectorAll(node.value);
-      return elements.length === 1 ? elements[0] : Array.from(elements);
-
-    case 'binary':
-      return evaluateBinary(node, ctx);
-
-    case 'possessive':
-    case 'member':
-      const obj = await evaluate(node.object, ctx);
-      if (obj == null) return undefined;
-      const prop = node.computed ? await evaluate(node.property, ctx) : node.property;
-      if (prop === 'values' && obj instanceof Element) {
-        if (obj instanceof HTMLFormElement) return new FormData(obj);
-        const fd = new FormData();
-        obj.querySelectorAll('input, select, textarea').forEach(input => {
-          const name = input.getAttribute('name');
-          if (name && 'value' in input) fd.append(name, input.value);
-        });
-        return fd;
-      }
-      return obj[prop];
-
-    case 'call': {
-      let callContext = null;
-      let callee;
-
-      if (node.callee.type === 'member' || node.callee.type === 'possessive') {
-        callContext = await evaluate(node.callee.object, ctx);
-        const p = node.callee.computed
-          ? await evaluate(node.callee.property, ctx)
-          : node.callee.property;
-        callee = callContext?.[p];
-      } else {
-        callee = await evaluate(node.callee, ctx);
-      }
-
-      const args = await Promise.all(node.args.map(a => evaluate(a, ctx)));
-      if (typeof callee === 'function') return callee.apply(callContext, args);
-      return undefined;
-    }
-${positionalExpressions ? `
-    case 'positional':
-      return evaluatePositional(node, ctx);
-` : ""}
-    default: return undefined;
-  }
-}
-
-async function evaluateBinary(node, ctx) {
-  if (node.operator === 'has') {
-    const left = await evaluate(node.left, ctx);
-    if (left instanceof Element && node.right.type === 'selector' && node.right.value.startsWith('.')) {
-      return left.classList.contains(node.right.value.slice(1));
-    }
-    return false;
-  }
-
-  const left = await evaluate(node.left, ctx);
-  const right = await evaluate(node.right, ctx);
-
-  switch (node.operator) {
-    case '+': return left + right;
-    case '-': return left - right;
-    case '*': return left * right;
-    case '/': return left / right;
-    case '%': return left % right;
-    case '==': case 'is': return left == right;
-    case '!=': case 'is not': return left != right;
-    case '<': return left < right;
-    case '>': return left > right;
-    case '<=': return left <= right;
-    case '>=': return left >= right;
-    case 'and': case '&&': return left && right;
-    case 'or': case '||': return left || right;
-    case 'contains': case 'includes':
-      if (typeof left === 'string') return left.includes(right);
-      if (Array.isArray(left)) return left.includes(right);
-      if (left instanceof Element) return left.contains(right);
-      return false;
-    case 'matches':
-      if (left instanceof Element) return left.matches(right);
-      if (typeof left === 'string') return new RegExp(right).test(left);
-      return false;
-    default: return undefined;
-  }
-}
-${positionalExpressions ? `
-function evaluatePositional(node, ctx) {
-  const target = node.target;
-  let elements = [];
-
-  let selector = null;
-  if (target.type === 'selector') {
-    selector = target.value;
-  } else if (target.type === 'identifier') {
-    selector = target.value;
-  } else if (target.type === 'htmlSelector') {
-    selector = target.value;
-  }
-  if (selector) {
-    elements = Array.from(document.querySelectorAll(selector));
-  }
-
-  switch (node.position) {
-    case 'first': return elements[0] || null;
-    case 'last': return elements[elements.length - 1] || null;
-    case 'next': return ctx.me.nextElementSibling;
-    case 'previous': return ctx.me.previousElementSibling;
-    case 'closest': return target.value ? ctx.me.closest(target.value) : null;
-    case 'parent': return ctx.me.parentElement;
-    default: return elements[0] || null;
-  }
-}
-` : ""}
-${needsStyleHelpers ? `
-const isStyleProp = (prop) => prop?.startsWith('*');
-const getStyleName = (prop) => prop.substring(1);
-const setStyleProp = (el, prop, value) => {
-  if (!isStyleProp(prop)) return false;
-  el.style.setProperty(getStyleName(prop), String(value));
-  return true;
-};
-` : ""}
-
-${needsElementArrayHelper ? `
-const toElementArray = (val) => {
-  if (Array.isArray(val)) return val.filter(e => e instanceof Element);
-  if (val instanceof Element) return [val];
-  if (typeof val === 'string') return Array.from(document.querySelectorAll(val));
-  return [];
-};
-` : ""}
-
-async function executeCommand(cmd, ctx) {
-  const getTarget = async () => {
-    // Support both HybridParser (cmd.target) and semantic AST (cmd.modifiers.on) formats
-    const target = cmd.target || cmd.modifiers?.on;
-    if (!target) return [ctx.me];
-    const t = await evaluate(target, ctx);
-    if (Array.isArray(t)) return t;
-    if (t instanceof Element) return [t];
-    if (typeof t === 'string') return Array.from(document.querySelectorAll(t));
-    return [ctx.me];
-  };
-
-  const getClassName = (node) => {
-    if (!node) return '';
-    if (node.type === 'selector') return node.value.slice(1);
-    if (node.type === 'string' || node.type === 'literal') {
-      const val = node.value;
-      return typeof val === 'string' && val.startsWith('.') ? val.slice(1) : String(val);
-    }
-    if (node.type === 'identifier') return node.value;
-    return '';
-  };
-
-  switch (cmd.name) {
-${commandCases}
-
-    default:
-      console.warn(\`${name} bundle: Unknown command '\${cmd.name}'\`);
-      return null;
-  }
-}
-${hasBlocks ? `
-async function executeBlock(block, ctx) {
-  switch (block.type) {
-${blockCases}
-
-    default:
-      console.warn(\`${name} bundle: Unknown block '\${block.type}'\`);
-      return null;
-  }
-}
-` : ""}
-async function executeSequence(nodes, ctx) {
-  let result;
-  for (const node of nodes) {
-    if (node.type === 'command') {
-      result = await executeCommand(node, ctx);
-    }${hasBlocks ? ` else if (['if', 'repeat', 'for', 'while', 'fetch'].includes(node.type)) {
-      result = await executeBlock(node, ctx);
-    }` : ""}
-  }
-  return result;
-}
-${hasBlocks ? `
-async function executeSequenceWithBlocks(nodes, ctx) {
-  try {
-    return await executeSequence(nodes, ctx);
-  } catch (e) {
-    if (e?.type === 'return') throw e;
-    throw e;
-  }
-}
-` : ""}
-async function executeAST(ast, me, event) {
-  const ctx = { me, event, locals: new Map() };
-
-  if (ast.type === 'sequence') {
-    ${hasReturn || hasBlocks ? "try { return await executeSequence(ast.commands, ctx); } catch (e) { if (e?.type === 'return') return e.value; throw e; }" : "return executeSequence(ast.commands, ctx);"}
-  }
-
-  if (ast.type === 'event') {
-    const eventNode = ast;
-    const eventName = eventNode.event;
-
-    if (eventName === 'init') {
-      ${hasReturn || hasBlocks ? "try { await executeSequence(eventNode.body, ctx); } catch (e) { if (e?.type !== 'return') throw e; }" : "await executeSequence(eventNode.body, ctx);"}
-      return;
-    }
-
-    const target = eventNode.filter ? await evaluate(eventNode.filter, ctx) : me;
-    const targetEl = target instanceof Element ? target : me;
-    const mods = eventNode.modifiers;
-
-    let handler = async (e) => {
-      if (mods.prevent) e.preventDefault();
-      if (mods.stop) e.stopPropagation();
-
-      const handlerCtx = {
-        me, event: e,
-        you: e.target instanceof Element ? e.target : undefined,
-        locals: new Map(),
-      };
-      ${hasReturn || hasBlocks ? "try { await executeSequence(eventNode.body, handlerCtx); } catch (err) { if (err?.type !== 'return') throw err; }" : "await executeSequence(eventNode.body, handlerCtx);"}
-    };
-
-    if (mods.debounce) {
-      let timeout;
-      const orig = handler;
-      handler = async (e) => {
-        clearTimeout(timeout);
-        timeout = setTimeout(() => orig(e), mods.debounce);
-      };
-    }
-
-    if (mods.throttle) {
-      let lastCall = 0;
-      const orig = handler;
-      handler = async (e) => {
-        const now = Date.now();
-        if (now - lastCall >= mods.throttle) {
-          lastCall = now;
-          await orig(e);
-        }
-      };
-    }
-
-    targetEl.addEventListener(eventName, handler, { once: !!mods.once });
-    return;
-  }
-
-  // Handle single command (not wrapped in event or sequence)
-  if (ast.type === 'command') {
-    return executeCommand(ast, ctx);
-  }
-
-  return null;
-}
-
-function processElement(el) {
-  const code = el.getAttribute('_');
-  if (!code) return;
-
-  try {
-    const ast = ${parserType === "lite" ? "parseLite(code)" : "new HybridParser(code).parse()"};
-    executeAST(ast, el);
-  } catch (err) {
-    console.error('LokaScript ${name} error:', err, 'Code:', code);
-  }
-}
-
-function processElements(root = document) {
-  const elements = root.querySelectorAll('[_]');
-  elements.forEach(processElement);
-}
-
-const api = {
-  version: '1.0.0-${name.toLowerCase().replace(/\s+/g, "-")}',
-
-  parse(code) {
-    return ${parserType === "lite" ? "parseLite(code)" : "new HybridParser(code).parse()"};
-  },
-
-  async execute(code, element) {
-    const me = element || document.body;
-    const ast = ${parserType === "lite" ? "parseLite(code)" : "new HybridParser(code).parse()"};
-    return executeAST(ast, me);
-  },
-
-  run: async (code, element) => api.execute(code, element),
-  eval: async (code, element) => api.execute(code, element),
-
-  init: processElements,
-  process: processElements,
-
-  commands: ${JSON.stringify(commands)},
-  ${blocks.length > 0 ? `blocks: ${JSON.stringify(blocks)},` : ""}
-  parserName: '${parserType}',
-};
+import { ${[...ENGINE_API_NAMES, ...modules].join(", ")} } from '@hyperfixi/engine';
+${semanticCode}
+register(${modules.join(", ")});
+${semantic.enabled ? "api.addSourceTransform(translateSource);\n" : ""}
+Object.assign(api, {
+${apiProps}
+});
 ${autoInit ? `
 if (typeof window !== 'undefined') {
-  window.${globalName} = api;
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', () => processElements());
-  } else {
-    processElements();
-  }
-${htmxIntegration ? `
-  document.addEventListener('htmx:afterSettle', (e) => {
-    const target = e.detail?.target;
-    if (target) processElements(target);
-  });
-` : ""}
-}
-` : ""}
-${esModule ? `
+${installGlobal}  boot();
+${htmxHooks}}
+` : ""}${esModule ? `
 export default api;
-export { api, processElements };
+export { api };
 ` : ""}`;
 }
 var Generator = class {
@@ -2535,148 +2005,70 @@ var Generator = class {
    * Generate bundle code from aggregated usage
    */
   generate(usage, options) {
-    const commands = [...usage.commands, ...options.extraCommands ?? []];
-    const blocks = [...usage.blocks, ...options.extraBlocks ?? []];
+    const commands = [.../* @__PURE__ */ new Set([...usage.commands, ...options.extraCommands ?? []])];
+    const blocks = [.../* @__PURE__ */ new Set([...usage.blocks, ...options.extraBlocks ?? []])];
     const positional = usage.positional || options.positional || false;
-    const semanticConfig = resolveSemanticConfig(options, usage.detectedLanguages);
-    if (commands.length === 0 && blocks.length === 0 && !positional && !semanticConfig.enabled) {
+    const reactivity = Boolean(
+      usage.needsReactivity || usage.needsBindToProperty || usage.htmx?.needsReactivity
+    );
+    const semantic = resolveSemanticConfig(options, usage.detectedLanguages);
+    if (commands.length === 0 && blocks.length === 0 && !positional && !reactivity && !semantic.enabled) {
       return this.generateEmptyBundle(options);
     }
-    const needsV4Bundle = usage.needsReactivity || usage.htmx?.needsHxLive || usage.htmx?.needsSSE || usage.htmx?.needsWS;
-    if (needsV4Bundle) {
-      if (this.debug) {
-        const triggers = [];
-        if (usage.htmx?.needsHxLive) triggers.push("hx-live");
-        if (usage.htmx?.needsSSE) triggers.push("sse-connect/sse-swap");
-        if (usage.htmx?.needsWS) triggers.push("ws-connect/ws-send");
-        if (usage.needsBindToProperty) triggers.push("bind-to-property");
-        else if (usage.needsReactivity) triggers.push("live/when/bind in _=");
+    const moduleUsage = {
+      commands,
+      blocks,
+      positional,
+      reactivity,
+      construct: usage.needsConstruct,
+      cookies: usage.needsCookies
+    };
+    const { modules, unknown } = resolveModules(moduleUsage);
+    if (this.debug) {
+      if (unknown.length > 0) {
         console.log(
-          `[hyperfixi] Detected htmx v4 features: ${triggers.join(", ")}
-  Using the hx-v4 premade bundle (auto-installs reactivity + SSE/WS).`
+          `[hyperfixi] Scanned names with no engine module (a form the engine dropped, or a false positive): ${unknown.join(", ")}`
         );
-        const onlyReactivity = usage.needsReactivity && !usage.htmx?.needsHxLive && !usage.htmx?.needsSSE && !usage.htmx?.needsWS && !usage.htmx?.hasHtmxAttributes;
-        if (onlyReactivity) {
-          console.log(
-            `  Note: this project uses reactivity only (no hx-*/sse-*/ws-* attributes). A reactivity-only fallback is parked pending size feedback.`
-          );
-        }
       }
-      return this.generateDevFallback("hx-v4");
-    }
-    const unsupportedCommands = this.getUnsupportedCommands(commands);
-    if (unsupportedCommands.length > 0) {
-      if (this.debug) {
+      if (usage.htmx?.needsHxLive || usage.htmx?.needsSSE || usage.htmx?.needsWS) {
         console.log(
-          `[hyperfixi] Commands detected that require full runtime: ${unsupportedCommands.join(", ")}
-  Falling back to full browser bundle for complete functionality.`
+          "[hyperfixi] hx-live / sse-* / ws-* attributes seen: these are htmx 4 features on the engine (load htmx 4 beside this bundle; a hyperscript-bodied hx-live is a `live \u2026 end` block)."
         );
       }
-      return this.generateDevFallback("full");
-    }
-    const parserType = (0, import_bundle_generator2.canUseLiteParser)(commands, blocks, positional) ? "lite" : "hybrid";
-    const config = {
-      name: options.bundleName ?? "ViteAutoGenerated",
-      commands,
-      blocks,
-      positionalExpressions: positional,
-      htmxIntegration: options.htmx ?? usage.htmx?.hasHtmxAttributes ?? false,
-      globalName: options.globalName ?? "hyperfixi",
-      parserType,
-      autoInit: true,
-      esModule: true
-    };
-    if (this.debug) {
       const bundleInfo = {
+        modules,
         commands,
         blocks,
         positional,
-        htmx: config.htmxIntegration,
-        semantic: semanticConfig.enabled,
-        parserType
+        reactivity
       };
-      if (semanticConfig.enabled && semanticConfig.bundleType) {
-        const sizeInfo = getSemanticBundleSize(semanticConfig.bundleType);
-        bundleInfo.semanticBundle = semanticConfig.bundleType;
+      if (semantic.enabled && semantic.bundleType) {
+        const sizeInfo = getSemanticBundleSize(semantic.bundleType);
+        bundleInfo.semanticBundle = semantic.bundleType;
         bundleInfo.semanticSize = sizeInfo.gzip;
-        bundleInfo.languages = [...semanticConfig.languages];
-        bundleInfo.grammar = semanticConfig.grammarEnabled;
+        bundleInfo.languages = [...semantic.languages];
+        bundleInfo.grammar = semantic.grammarEnabled;
       }
       console.log("[hyperfixi] Generating bundle:", bundleInfo);
-      if (semanticConfig.bundleType === "all" || semanticConfig.bundleType === "priority") {
+      if (semantic.bundleType === "all" || semantic.bundleType === "priority") {
         console.log(
-          `[hyperfixi] Note: Using '${semanticConfig.bundleType}' semantic bundle (${getSemanticBundleSize(semanticConfig.bundleType).gzip}). Consider using 'region' option to select a smaller regional bundle if all languages aren't needed.`
+          `[hyperfixi] Note: Using '${semantic.bundleType}' semantic bundle (${getSemanticBundleSize(semantic.bundleType).gzip}). Consider using 'region' option to select a smaller regional bundle if all languages aren't needed.`
         );
       }
     }
-    let bundleCode = generateBundleCode(config);
-    if (semanticConfig.enabled) {
-      bundleCode = this.addSemanticIntegration(bundleCode, semanticConfig);
-    }
-    return bundleCode;
-  }
-  /**
-   * Add semantic integration code to the bundle
-   */
-  addSemanticIntegration(bundleCode, config) {
-    const semanticCode = generateSemanticIntegrationCode(config);
-    const semanticExports = getSemanticExports(config);
-    const parserImportEnd = bundleCode.indexOf("// Runtime state");
-    if (parserImportEnd === -1) {
-      bundleCode = semanticCode + "\n" + bundleCode;
-    } else {
-      bundleCode = bundleCode.slice(0, parserImportEnd) + semanticCode + "\n\n" + bundleCode.slice(parserImportEnd);
-    }
-    bundleCode = bundleCode.replace(
-      /function processElement\(el\) \{\s*const code = el\.getAttribute\('_'\);\s*if \(!code\) return;\s*try \{\s*const ast = (?:new HybridParser\(code\)\.parse\(\)|parseLite\(code\));/g,
-      `function processElement(el) {
-  const code = el.getAttribute('_');
-  if (!code) return;
-
-  try {
-    const ast = parseWithSemantic(code);`
-    );
-    bundleCode = bundleCode.replace(
-      /parse\(code\) \{\s*return (?:new HybridParser\(code\)\.parse\(\)|parseLite\(code\));/g,
-      `parse(code, lang = null) {
-    return parseWithSemantic(code, lang);`
-    );
-    bundleCode = bundleCode.replace(
-      /async execute\(code, element\) \{\s*const me = element \|\| document\.body;\s*const ast = (?:new HybridParser\(code\)\.parse\(\)|parseLite\(code\));/g,
-      `async execute(code, element, lang = null) {
-    const me = element || document.body;
-    const ast = parseWithSemantic(code, lang);`
-    );
-    if (semanticExports.length > 0) {
-      const apiExportsMarkerRegex = /parserName: '(?:lite|hybrid)',/;
-      const additionalApiProps = semanticExports.map((exp) => `  ${exp},`).join("\n");
-      bundleCode = bundleCode.replace(
-        apiExportsMarkerRegex,
-        `parserName: 'semantic',
-${additionalApiProps}`
-      );
-    }
-    return bundleCode;
-  }
-  /**
-   * Get commands that require the full runtime and are not available in generated bundles
-   */
-  getUnsupportedCommands(commands) {
-    const unsupported = [];
-    for (const cmd of commands) {
-      if (import_bundle_generator2.FULL_RUNTIME_ONLY_COMMANDS.includes(cmd)) {
-        unsupported.push(cmd);
-      } else if (!(0, import_bundle_generator2.isAvailableCommand)(cmd) && !COMMAND_IMPLEMENTATIONS[cmd]) {
-        unsupported.push(cmd);
-      }
-    }
-    return unsupported;
-  }
-  /**
-   * Check if any commands require full runtime and should trigger fallback
-   */
-  requiresFullRuntime(commands) {
-    return this.getUnsupportedCommands(commands).length > 0;
+    return generateBundleCode({
+      name: options.bundleName ?? "ViteAutoGenerated",
+      modules,
+      commands,
+      blocks,
+      positional,
+      reactivity,
+      htmxIntegration: options.htmx ?? usage.htmx?.hasHtmxAttributes ?? false,
+      globalName: options.globalName ?? "hyperfixi",
+      autoInit: true,
+      esModule: true,
+      semantic
+    });
   }
   /**
    * Generate an empty bundle when no hyperscript is detected
@@ -2684,7 +2076,7 @@ ${additionalApiProps}`
   generateEmptyBundle(options) {
     const globalName = options.globalName ?? "hyperfixi";
     return `/**
- * LokaScript Empty Bundle (Auto-Generated)
+ * hyperfixi Empty Bundle (Auto-Generated)
  *
  * No hyperscript usage detected. This bundle provides a minimal API.
  * Add hyperscript attributes (_="...") to your HTML to enable features.
@@ -2694,28 +2086,24 @@ ${additionalApiProps}`
 
 const api = {
   version: '1.0.0-empty',
-  commands: [],
-  parserName: 'none',
+  bundle: { generator: '@hyperfixi/vite-plugin', modules: [], commands: [], blocks: [], languages: [] },
 
   parse() {
-    console.warn('LokaScript: No parser loaded. Add hyperscript to your HTML to enable parsing.');
-    return { type: 'empty' };
+    console.warn('hyperfixi: No engine loaded. Add hyperscript to your HTML to enable parsing.');
+    return { errors: [] };
   },
 
-  async execute(code, element) {
-    console.warn('LokaScript: No commands loaded. Detected commands will be automatically included.');
+  async evaluate(code, element) {
+    console.warn('hyperfixi: No modules loaded. Detected commands will be automatically included.');
     return null;
   },
 
-  run: async (code, element) => api.execute(code, element),
-  eval: async (code, element) => api.execute(code, element),
-
-  init() {},
+  processNode() {},
   process() {},
 };
 
 if (typeof window !== 'undefined') {
-  (window).${globalName} = api;
+  window.${globalName} = api;
 }
 
 export default api;
@@ -2723,947 +2111,40 @@ export { api };
 `;
   }
   /**
-   * Generate a development fallback bundle.
+   * Generate a development fallback bundle: the engine with every module.
    *
-   * `hx-v4` re-exports the htmx v4 surface bundle: full runtime +
-   * htmx-compat + reactivity (hx-live, bind, when) + SSE + WS, all
-   * auto-installed. The vite plugin selects this when scanner detects
-   * any of `hx-live`, `sse-connect`/`sse-swap`, `ws-connect`/`ws-send`,
-   * or `bind ... to <expr>.<prop>` in `_=` bodies — the minimal
-   * generator can't satisfy those features (the slim runtime lacks the
-   * reactive notify chain and the SSE/WS modules). Larger artifact but
-   * correct end-to-end.
+   * One shape serves every former fallback (`hybrid-complete`, `full`, `hx-v4`):
+   * the engine's `everything` is 34 KB gzipped and carries the reactive features
+   * (`live`, `when`, `bind`) the hx-v4 fallback existed for. The argument is kept
+   * for the option's type; its value no longer changes the output.
    */
-  generateDevFallback(fallback) {
-    const bundle = fallback === "full" ? "@hyperfixi/core/browser" : fallback === "hx-v4" ? "@hyperfixi/core/browser/hybrid-hx-v4" : "@hyperfixi/core/browser/hybrid-complete";
+  generateDevFallback(_fallback = "everything") {
     return `/**
- * LokaScript Dev Fallback Bundle
+ * hyperfixi Dev Fallback Bundle
  *
- * Using pre-built ${fallback} bundle for faster development.
- * Production builds will generate minimal bundles.
+ * The engine with every module, for faster development rebuilds.
+ * Production builds register only the modules the project uses.
  *
  * Generated by: @hyperfixi/vite-plugin
  */
 
-export * from '${bundle}';
-export { default } from '${bundle}';
-`;
-  }
-};
+import { api, boot, register, everything } from '@hyperfixi/engine';
 
-// src/compiler.ts
-var import_parser_core = require("@hyperfixi/core/parser/hybrid/parser-core");
-var semanticParse = null;
-var supportsLanguage = null;
-var buildASTFn = null;
-function setSemanticParser(parse, supports, buildAST) {
-  semanticParse = parse;
-  supportsLanguage = supports;
-  buildASTFn = buildAST;
-}
-function clearSemanticParser() {
-  semanticParse = null;
-  supportsLanguage = null;
-  buildASTFn = null;
-}
-function hasSemanticParser() {
-  return semanticParse !== null && supportsLanguage !== null && buildASTFn !== null;
-}
-var SEMANTIC_CONFIDENCE_THRESHOLD = 0.7;
-var multilingualAliases = {};
-var multilingualRegex = null;
-function setMultilingualAliases(aliases) {
-  multilingualAliases = { ...aliases };
-  if (Object.keys(aliases).length > 0) {
-    const escapedKeys = Object.keys(aliases).map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-    multilingualRegex = new RegExp(`(^|\\s)(${escapedKeys})(?=\\s|\\.|$)`, "g");
-  } else {
-    multilingualRegex = null;
-  }
-}
-function preprocessMultilingual(code) {
-  if (!multilingualRegex) return code;
-  return code.replace(multilingualRegex, (match, prefix, keyword) => {
-    const english = multilingualAliases[keyword];
-    return english ? prefix + english : match;
-  });
-}
-function sanitizeClassName(name) {
-  if (!/^-?[a-zA-Z_][a-zA-Z0-9_-]*$/.test(name)) {
-    return null;
-  }
-  return name;
-}
-function sanitizeSelector(selector) {
-  return selector.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\0/g, "");
-}
-function hashScript(script) {
-  let hash = 5381;
-  for (let i = 0; i < script.length; i++) {
-    hash = (hash << 5) + hash ^ script.charCodeAt(i);
-  }
-  return Math.abs(hash).toString(36).slice(0, 4);
-}
-var usedIds = /* @__PURE__ */ new Set();
-function resetCompiler() {
-  usedIds.clear();
-}
-function generateHandlerId(event, command, script) {
-  const hash = hashScript(script);
-  let id = `${event}_${command}_${hash}`;
-  let suffix = 0;
-  while (usedIds.has(id)) {
-    id = `${event}_${command}_${hash}${suffix++}`;
-  }
-  usedIds.add(id);
-  return id;
-}
-function compile(script, options = {}) {
-  const { language = "en", debug = false } = options;
-  try {
-    let ast;
-    if (language !== "en" && semanticParse && supportsLanguage && buildASTFn) {
-      if (supportsLanguage(language)) {
-        const result = semanticParse(script, language);
-        if (result.node && result.confidence >= SEMANTIC_CONFIDENCE_THRESHOLD) {
-          const { ast: builtAST, warnings } = buildASTFn(result.node);
-          if (debug && warnings.length > 0) {
-            console.log(`[hyperfixi] Semantic AST warnings for "${script}":`, warnings);
-          }
-          ast = builtAST;
-          if (debug) {
-            console.log(
-              `[hyperfixi] Compiled ${language}: "${script}" (confidence: ${result.confidence.toFixed(2)})`
-            );
-          }
-        } else {
-          if (debug) {
-            const reason = result.error || `low confidence (${result.confidence.toFixed(2)})`;
-            console.log(`[hyperfixi] Semantic parse failed for "${script}": ${reason}`);
-          }
-          return null;
-        }
-      } else {
-        if (debug) {
-          console.log(`[hyperfixi] Language "${language}" not supported by semantic parser`);
-        }
-        return null;
-      }
-    } else if (language !== "en") {
-      if (debug) {
-        console.log(
-          `[hyperfixi] Semantic parser not available for "${language}". Install @lokascript/semantic and call setSemanticParser().`
-        );
-      }
-      return null;
-    } else {
-      const preprocessedScript = preprocessMultilingual(script);
-      const parser = new import_parser_core.HybridParser(preprocessedScript);
-      ast = parser.parse();
-    }
-    return compileAST(ast, script);
-  } catch (error) {
-    if (debug) {
-      console.warn(`[hyperfixi] Failed to compile: ${script}`, error);
-    }
-    return null;
-  }
-}
-function extractPrimaryCommand(body) {
-  if (body.length === 0) return "handler";
-  const first = body[0];
-  if (first.type === "command") {
-    return first.name || "cmd";
-  }
-  return first.type || "handler";
-}
-function compileAST(ast, original) {
-  if (ast.type !== "event") {
-    return null;
-  }
-  const eventNode = ast;
-  const event = eventNode.event;
-  const modifiers = eventNode.modifiers || {};
-  const body = eventNode.body || [];
-  const { code, needsEvaluator, needsLocals, needsGlobals } = compileBody(body);
-  if (code === null || code === "") {
-    return null;
-  }
-  const command = extractPrimaryCommand(body);
-  const id = generateHandlerId(event, command, original);
-  return {
-    id,
-    event,
-    modifiers: {
-      prevent: modifiers.prevent,
-      stop: modifiers.stop,
-      once: modifiers.once,
-      debounce: modifiers.debounce,
-      throttle: modifiers.throttle
-    },
-    code,
-    needsEvaluator: needsEvaluator || needsLocals || needsGlobals,
-    original
-  };
-}
-function compileBody(nodes) {
-  const statements = [];
-  let needsEvaluator = false;
-  let needsLocals = false;
-  let needsGlobals = false;
-  for (const node of nodes) {
-    const result = compileNode(node);
-    if (result === null) {
-      return { code: null, needsEvaluator: false, needsLocals: false, needsGlobals: false };
-    }
-    statements.push(result.code);
-    needsEvaluator = needsEvaluator || result.needsEvaluator;
-    needsLocals = needsLocals || result.needsLocals;
-    needsGlobals = needsGlobals || result.needsGlobals;
-  }
-  return {
-    code: statements.join("\n"),
-    needsEvaluator,
-    needsLocals,
-    needsGlobals
-  };
-}
-function compileNode(node) {
-  if (node.type === "command") {
-    return compileCommand(node);
-  }
-  return null;
-}
-function compileCommand(cmd) {
-  const target = cmd.target ? compileTarget(cmd.target) : "m";
-  switch (cmd.name) {
-    case "toggle":
-      return compileToggle(cmd.args, target);
-    case "add":
-      return compileAdd(cmd.args, target);
-    case "remove":
-      return compileRemove(cmd.args, target);
-    case "removeClass":
-      return compileRemoveClass(cmd.args, target);
-    case "show":
-      return {
-        code: `${target}.style.display = ''`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "hide":
-      return {
-        code: `${target}.style.display = 'none'`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "focus":
-      return {
-        code: `${target}.focus()`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "blur":
-      return {
-        code: `${target}.blur()`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "log":
-      return compileLog(cmd.args);
-    case "set":
-      return compileSet(cmd.args);
-    case "increment":
-      return compileIncrement(cmd.args);
-    case "decrement":
-      return compileDecrement(cmd.args);
-    case "put":
-      return compilePut(cmd.args, target, cmd.modifier);
-    case "send":
-    case "trigger":
-      return compileTrigger(cmd.args, target);
-    case "wait":
-      return compileWait(cmd.args);
-    default:
-      return null;
-  }
-}
-function compileToggle(args, target) {
-  const className = extractClassName(args[0]);
-  if (!className) return null;
-  if (target === "m") {
-    return {
-      code: `m.classList.toggle('${className}')`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return {
-    code: `${target}.forEach(el => el.classList.toggle('${className}'))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileAdd(args, target) {
-  const className = extractClassName(args[0]);
-  if (!className) return null;
-  if (target === "m") {
-    return {
-      code: `m.classList.add('${className}')`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return {
-    code: `${target}.forEach(el => el.classList.add('${className}'))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileRemove(args, target) {
-  if (!args || args.length === 0) {
-    return {
-      code: `${target}.remove()`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  const className = extractClassName(args[0]);
-  if (!className) return null;
-  if (target === "m") {
-    return {
-      code: `m.classList.remove('${className}')`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return {
-    code: `${target}.forEach(el => el.classList.remove('${className}'))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileRemoveClass(args, target) {
-  const className = extractClassName(args[0]);
-  if (!className) return null;
-  if (target === "m") {
-    return {
-      code: `m.classList.remove('${className}')`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return {
-    code: `${target}.forEach(el => el.classList.remove('${className}'))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileLog(args) {
-  const compiled = args.map(compileExpression).filter(Boolean);
-  if (compiled.length !== args.length) {
-    return {
-      code: `console.log(${compiled.join(", ")})`,
-      needsEvaluator: true,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return {
-    code: `console.log(${compiled.join(", ")})`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileSet(args) {
-  if (args.length < 2) return null;
-  const [target, value] = args;
-  const compiledValue = compileExpression(value);
-  if (!compiledValue) return null;
-  if (target.type === "variable") {
-    const varNode = target;
-    if (varNode.scope === "local") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `L.${varName} = ${compiledValue}`,
-        needsEvaluator: false,
-        needsLocals: true,
-        needsGlobals: false
-      };
-    }
-    if (varNode.scope === "global") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `G.${varName} = ${compiledValue}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: true
-      };
-    }
-  }
-  if (target.type === "possessive") {
-    const possNode = target;
-    const obj = compileExpression(possNode.object);
-    const prop = possNode.property;
-    if (!obj) return null;
-    if (prop.startsWith("*")) {
-      const styleProp = prop.slice(1);
-      return {
-        code: `${obj}.style.${styleProp} = ${compiledValue}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    }
-    return {
-      code: `${obj}.${prop} = ${compiledValue}`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  if (target.type === "member") {
-    const memNode = target;
-    const obj = compileExpression(memNode.object);
-    const prop = typeof memNode.property === "string" ? memNode.property : null;
-    if (!obj || !prop) return null;
-    if (prop.startsWith("*")) {
-      const styleProp = prop.slice(1);
-      return {
-        code: `${obj}.style.${styleProp} = ${compiledValue}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    }
-    return {
-      code: `${obj}.${prop} = ${compiledValue}`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return null;
-}
-function compileIncrement(args) {
-  if (args.length < 1) return null;
-  const target = args[0];
-  const amount = args.length > 1 ? compileExpression(args[1]) : "1";
-  if (target.type === "variable") {
-    const varNode = target;
-    if (varNode.scope === "local") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `L.${varName} = (L.${varName} || 0) + ${amount}`,
-        needsEvaluator: false,
-        needsLocals: true,
-        needsGlobals: false
-      };
-    }
-    if (varNode.scope === "global") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `G.${varName} = (G.${varName} || 0) + ${amount}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: true
-      };
-    }
-  }
-  const compiled = compileExpression(target);
-  if (compiled) {
-    return {
-      code: `${compiled}.textContent = (parseFloat(${compiled}.textContent) || 0) + ${amount}`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return null;
-}
-function compileDecrement(args) {
-  if (args.length < 1) return null;
-  const target = args[0];
-  const amount = args.length > 1 ? compileExpression(args[1]) : "1";
-  if (target.type === "variable") {
-    const varNode = target;
-    if (varNode.scope === "local") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `L.${varName} = (L.${varName} || 0) - ${amount}`,
-        needsEvaluator: false,
-        needsLocals: true,
-        needsGlobals: false
-      };
-    }
-    if (varNode.scope === "global") {
-      const varName = varNode.name.slice(1);
-      return {
-        code: `G.${varName} = (G.${varName} || 0) - ${amount}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: true
-      };
-    }
-  }
-  const compiled = compileExpression(target);
-  if (compiled) {
-    return {
-      code: `${compiled}.textContent = (parseFloat(${compiled}.textContent) || 0) - ${amount}`,
-      needsEvaluator: false,
-      needsLocals: false,
-      needsGlobals: false
-    };
-  }
-  return null;
-}
-function compilePut(args, target, modifier) {
-  if (args.length < 1) return null;
-  const content = compileExpression(args[0]);
-  if (!content) return null;
-  const mod = modifier || "into";
-  switch (mod) {
-    case "into":
-      return {
-        code: `${target}.innerHTML = ${content}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "before":
-      return {
-        code: `${target}.insertAdjacentHTML('beforebegin', ${content})`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "after":
-      return {
-        code: `${target}.insertAdjacentHTML('afterend', ${content})`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "at start of":
-      return {
-        code: `${target}.insertAdjacentHTML('afterbegin', ${content})`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    case "at end of":
-      return {
-        code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-    default:
-      return {
-        code: `${target}.innerHTML = ${content}`,
-        needsEvaluator: false,
-        needsLocals: false,
-        needsGlobals: false
-      };
-  }
-}
-function compileTrigger(args, target) {
-  if (args.length < 1) return null;
-  const eventName = compileExpression(args[0]);
-  if (!eventName) return null;
-  return {
-    code: `${target}.dispatchEvent(new CustomEvent(${eventName}, { bubbles: true }))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileWait(args) {
-  if (args.length < 1) return null;
-  const duration = compileExpression(args[0]);
-  if (!duration) return null;
-  return {
-    code: `await new Promise(r => setTimeout(r, ${duration}))`,
-    needsEvaluator: false,
-    needsLocals: false,
-    needsGlobals: false
-  };
-}
-function compileExpression(node) {
-  if (!node) return null;
-  switch (node.type) {
-    case "literal": {
-      const litNode = node;
-      return JSON.stringify(litNode.value);
-    }
-    case "identifier": {
-      const idNode = node;
-      const val = idNode.value;
-      if (val === "me" || val === "my") return "m";
-      if (val === "you") return "y";
-      if (val === "it") return "it";
-      if (val === "event") return "e";
-      if (val === "body") return "document.body";
-      if (val === "document") return "document";
-      if (val === "window") return "window";
-      return val;
-    }
-    case "variable": {
-      const varNode = node;
-      const name = varNode.name.slice(1);
-      return varNode.scope === "local" ? `L.${name}` : `G.${name}`;
-    }
-    case "selector": {
-      const selNode = node;
-      const sanitized = sanitizeSelector(selNode.value);
-      return `document.querySelector('${sanitized}')`;
-    }
-    case "possessive": {
-      const possNode = node;
-      const obj = compileExpression(possNode.object);
-      const prop = possNode.property;
-      if (!obj) return null;
-      if (prop.startsWith("*")) {
-        return `${obj}.style.${prop.slice(1)}`;
-      }
-      if (prop === "values") {
-        return `(function(el){if(el instanceof HTMLFormElement)return new FormData(el);var fd=new FormData();el.querySelectorAll('input,select,textarea').forEach(function(i){var n=i.getAttribute('name');if(n&&'value'in i)fd.append(n,i.value)});return fd})(${obj})`;
-      }
-      return `${obj}.${prop}`;
-    }
-    case "member": {
-      const memNode = node;
-      const obj = compileExpression(memNode.object);
-      const prop = typeof memNode.property === "string" ? memNode.property : null;
-      if (!obj || !prop) return null;
-      if (prop.startsWith("*")) {
-        return `${obj}.style.${prop.slice(1)}`;
-      }
-      return `${obj}.${prop}`;
-    }
-    case "binary": {
-      const binNode = node;
-      const left = compileExpression(binNode.left);
-      const right = compileExpression(binNode.right);
-      if (!left || !right) return null;
-      const op = binNode.operator;
-      switch (op) {
-        case "+":
-        case "-":
-        case "*":
-        case "/":
-        case "%":
-          return `(${left} ${op} ${right})`;
-        case "==":
-        case "is":
-          return `(${left} == ${right})`;
-        case "!=":
-        case "is not":
-          return `(${left} != ${right})`;
-        case "<":
-        case ">":
-        case "<=":
-        case ">=":
-          return `(${left} ${op} ${right})`;
-        case "and":
-        case "&&":
-          return `(${left} && ${right})`;
-        case "or":
-        case "||":
-          return `(${left} || ${right})`;
-        case "has": {
-          const rightSel = binNode.right;
-          const className = rightSel.value?.slice(1) || "";
-          const sanitizedClass = sanitizeClassName(className);
-          if (!sanitizedClass) return null;
-          return `${left}.classList.contains('${sanitizedClass}')`;
-        }
-        default:
-          return null;
-      }
-    }
-    case "call": {
-      const callNode = node;
-      const callee = callNode.callee;
-      const args = (callNode.args || []).map(compileExpression);
-      if (args.some((a) => a === null)) return null;
-      if (callee.type === "member" || callee.type === "possessive") {
-        const memCallee = callee;
-        const obj = compileExpression(memCallee.object);
-        const prop = typeof memCallee.property === "string" ? memCallee.property : null;
-        if (!obj || !prop) return null;
-        return `${obj}.${prop}(${args.join(", ")})`;
-      }
-      const fn = compileExpression(callee);
-      if (!fn) return null;
-      return `${fn}(${args.join(", ")})`;
-    }
-    case "positional": {
-      const posNode = node;
-      const position = posNode.position;
-      const target = posNode.target;
-      switch (position) {
-        case "first":
-          if (target?.type === "selector") {
-            const selNode = target;
-            const sanitized = sanitizeSelector(selNode.value);
-            return `document.querySelector('${sanitized}')`;
-          }
-          return null;
-        // Arrays need runtime
-        case "last":
-          if (target?.type === "selector") {
-            const selNode = target;
-            const sanitized = sanitizeSelector(selNode.value);
-            return `(()=>{const e=document.querySelectorAll('${sanitized}');return e[e.length-1]})()`;
-          }
-          return null;
-        // Arrays need runtime
-        case "next":
-          return "m.nextElementSibling";
-        case "previous":
-          return "m.previousElementSibling";
-        case "closest":
-          if (target?.type === "selector") {
-            const selNode = target;
-            const sanitized = sanitizeSelector(selNode.value);
-            return `m.closest('${sanitized}')`;
-          }
-          return null;
-        case "parent":
-          return "m.parentElement";
-        default:
-          return null;
-      }
-    }
-    default:
-      return null;
-  }
-}
-function compileTarget(target) {
-  if (target.type === "identifier") {
-    const idNode = target;
-    if (idNode.value === "me" || idNode.value === "my") return "m";
-    if (idNode.value === "you") return "y";
-  }
-  if (target.type === "selector") {
-    const selNode = target;
-    const sanitized = sanitizeSelector(selNode.value);
-    return `document.querySelectorAll('${sanitized}')`;
-  }
-  const compiled = compileExpression(target);
-  return compiled || "m";
-}
-function extractClassName(node) {
-  if (!node) return null;
-  if (node.type === "selector") {
-    const selNode = node;
-    const val = selNode.value;
-    const rawClass = val.startsWith(".") ? val.slice(1) : val;
-    return sanitizeClassName(rawClass);
-  }
-  if (node.type === "literal" || node.type === "string") {
-    const litNode = node;
-    const val = litNode.value;
-    if (typeof val === "string") {
-      const rawClass = val.startsWith(".") ? val.slice(1) : val;
-      return sanitizeClassName(rawClass);
-    }
-  }
-  if (node.type === "identifier") {
-    const idNode = node;
-    return sanitizeClassName(idNode.value);
-  }
-  return null;
-}
-
-// src/compiled-generator.ts
-function generateSourceMapTable(handlers) {
-  if (handlers.length === 0) return "";
-  const lines = [
-    " *",
-    " * Handler Source Map:",
-    " * \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"
-  ];
-  for (const h of handlers) {
-    const original = h.original.replace(/\n/g, " ").slice(0, 40);
-    const truncated = original.length < h.original.length ? original + "..." : original;
-    lines.push(` * \u2502 ${h.id.padEnd(20)} \u2190 ${truncated.padEnd(40)} \u2502`);
-  }
-  lines.push(" * \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
-  lines.push(" *");
-  return lines.join("\n");
-}
-function generateCompiledBundle(options) {
-  const {
-    handlers,
-    needsLocals,
-    needsGlobals,
-    globalName = "hyperfixi",
-    htmx = false,
-    debug = false
-  } = options;
-  const handlerEntries = handlers.map((h) => {
-    const isAsync = h.code.includes("await");
-    const fn = isAsync ? `async(m,e,y)=>{${h.code}}` : `(m,e,y)=>{${h.code}}`;
-    if (debug) {
-      const escapedOriginal = h.original.replace(/\*/g, "\\*").replace(/\n/g, " ");
-      return `
-  /* ${escapedOriginal} */
-  ${h.id}:${fn}`;
-    }
-    return `${h.id}:${fn}`;
-  });
-  const registrations = handlers.map((h) => {
-    const modsCode = generateModifiersCode(h);
-    return `    case '${h.id}': r(el,'${h.event}',H.${h.id}${modsCode}); break;`;
-  });
-  const localsCode = needsLocals ? "const L={};" : "";
-  const globalsCode = needsGlobals ? "const G={};" : "";
-  const sourceMapTable = debug ? generateSourceMapTable(handlers) : "";
-  return `/**
- * HyperFixi Compiled Bundle (Auto-Generated)
- *
- * Pre-compiled hyperscript - no runtime parser needed!
- * Handlers: ${handlers.length}
- *
- * DO NOT EDIT - Regenerate with build.
-${sourceMapTable} */
-
-${localsCode}${globalsCode}
-const H={${handlerEntries.join(",")}};
-
-function r(el,ev,fn${hasModifiers(handlers) ? ",m" : ""}){
-  let h=e=>fn(el,e,e.target);
-${generateModifierWrappers(handlers)}
-  el.addEventListener(ev,h${hasOnce(handlers) ? ",{once:m?.o}" : ""});
-}
-
-function init(root=document){
-  root.querySelectorAll('[data-h]').forEach(el=>{
-    switch(el.dataset.h){
-${registrations.join("\n")}
-    }
-  });
-}
-
-${htmx ? `document.addEventListener('htmx:afterSettle',e=>init(e.detail?.target));` : ""}
-
-const api={
-  version:'1.0.0-compiled',
-  commands:${JSON.stringify(handlers.map((h) => h.id))},
-  init,
-  process:init,
-};
+register(...everything);
+Object.assign(api, {
+  bundle: { generator: '@hyperfixi/vite-plugin', modules: ['everything'], commands: [], blocks: [], languages: [] },
+});
 
-if(typeof window!=='undefined'){
-  window.${globalName}=api;
-  document.readyState==='loading'
-    ?document.addEventListener('DOMContentLoaded',()=>init())
-    :init();
+if (typeof window !== 'undefined') {
+  window.hyperfixi = api;
+  boot();
 }
 
 export default api;
-export{api,init};
+export { api };
 `;
-}
-function generateModifiersCode(h) {
-  const mods = [];
-  if (h.modifiers.prevent) mods.push("p:1");
-  if (h.modifiers.stop) mods.push("s:1");
-  if (h.modifiers.once) mods.push("o:1");
-  if (h.modifiers.debounce) mods.push(`d:${h.modifiers.debounce}`);
-  if (h.modifiers.throttle) mods.push(`t:${h.modifiers.throttle}`);
-  if (mods.length === 0) return "";
-  return `,{${mods.join(",")}}`;
-}
-function hasModifiers(handlers) {
-  return handlers.some(
-    (h) => h.modifiers.prevent || h.modifiers.stop || h.modifiers.once || h.modifiers.debounce || h.modifiers.throttle
-  );
-}
-function hasOnce(handlers) {
-  return handlers.some((h) => h.modifiers.once);
-}
-function generateModifierWrappers(handlers) {
-  const lines = [];
-  if (handlers.some((h) => h.modifiers.prevent || h.modifiers.stop)) {
-    lines.push(
-      `  if(m?.p||m?.s){const _h=h;h=e=>{m.p&&e.preventDefault();m.s&&e.stopPropagation();_h(e.currentTarget,e,e.target)};}`
-    );
-  }
-  if (handlers.some((h) => h.modifiers.debounce)) {
-    lines.push(
-      `  if(m?.d){let t;const _h=h;h=e=>{clearTimeout(t);t=setTimeout(()=>_h(e.currentTarget,e,e.target),m.d)};}`
-    );
-  }
-  if (handlers.some((h) => h.modifiers.throttle)) {
-    lines.push(
-      `  if(m?.t){let l=0;const _h=h;h=e=>{const n=Date.now();if(n-l>=m.t){l=n;_h(e.currentTarget,e,e.target)}};}`
-    );
   }
-  return lines.join("\n");
-}
-
-// src/html-transformer.ts
-function transformHTML(html, handlerMap, fallbackScripts) {
-  let modified = false;
-  const fallbacks = [];
-  const patterns = [
-    /(\s)_\s*=\s*"([^"]+)"/g,
-    // _="..."
-    /(\s)_\s*=\s*'([^']+)'/g,
-    // _='...'
-    /(\s)_\s*=\s*`([^`]+)`/g
-    // _=`...`
-  ];
-  let result = html;
-  for (const pattern of patterns) {
-    result = result.replace(pattern, (match, whitespace, script) => {
-      const handlerId = handlerMap.get(script);
-      if (handlerId) {
-        modified = true;
-        return `${whitespace}data-h="${handlerId}"`;
-      }
-      if (fallbackScripts.has(script)) {
-        fallbacks.push(script);
-        return match;
-      }
-      fallbacks.push(script);
-      return match;
-    });
-  }
-  return {
-    code: result,
-    modified,
-    fallbacks
-  };
-}
-function extractScripts(html) {
-  const scripts = [];
-  const patterns = [/_\s*=\s*"([^"]+)"/g, /_\s*=\s*'([^']+)'/g, /_\s*=\s*`([^`]+)`/g];
-  for (const pattern of patterns) {
-    let match;
-    while (match = pattern.exec(html)) {
-      scripts.push(match[1]);
-    }
-  }
-  return scripts;
-}
+};
 
 // src/server-bridge-integration.ts
 var import_node_path = require("path");
@@ -3967,10 +2448,15 @@ function computeUsageHash(usage) {
     usage.htmx.needsReactivity
   ].map((f) => f ? "1" : "0").join("") : "none";
   const reactivity = `${usage.needsReactivity ? 1 : 0}${usage.needsBindToProperty ? 1 : 0}`;
-  return `${commands}|${blocks}|${usage.positional}|${languages}|${htmx}|${reactivity}`;
+  const extras = `${usage.needsConstruct ? 1 : 0}${usage.needsCookies ? 1 : 0}`;
+  return `${commands}|${blocks}|${usage.positional}|${languages}|${htmx}|${reactivity}|${extras}`;
 }
 function hyperfixi(options = {}) {
-  const mode = options.mode ?? "interpret";
+  if (options.mode === "compile") {
+    console.warn(
+      `[hyperfixi] mode: "compile" was removed in 4.0 (it compiled with @hyperfixi/core's parser); building the bundle on @hyperfixi/engine instead.`
+    );
+  }
   const scanner = new Scanner(options);
   const aggregator = new Aggregator();
   const generator = new Generator(options);
@@ -3980,11 +2466,6 @@ function hyperfixi(options = {}) {
   let cachedBundle = null;
   let lastUsageHash = "";
   let isDev = false;
-  const compiledHandlers = [];
-  const handlerMap = /* @__PURE__ */ new Map();
-  const fallbackScripts = /* @__PURE__ */ new Set();
-  let needsLocals = false;
-  let needsGlobals = false;
   function invalidateVirtualModule() {
     if (!server) return;
     const mod = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
@@ -3996,32 +2477,6 @@ function hyperfixi(options = {}) {
       }
     }
   }
-  function compileScript(script) {
-    if (handlerMap.has(script)) {
-      return handlerMap.get(script);
-    }
-    if (fallbackScripts.has(script)) {
-      return null;
-    }
-    const handler = compile(script);
-    if (handler) {
-      compiledHandlers.push(handler);
-      handlerMap.set(script, handler.id);
-      if (handler.needsEvaluator) {
-        if (handler.code.includes("L.")) needsLocals = true;
-        if (handler.code.includes("G.")) needsGlobals = true;
-      }
-      if (options.debug) {
-        console.log(`[hyperfixi] Compiled: "${script}" -> ${handler.id}`);
-      }
-      return handler.id;
-    }
-    fallbackScripts.add(script);
-    if (options.debug) {
-      console.log(`[hyperfixi] Fallback (not compilable): "${script}"`);
-    }
-    return null;
-  }
   function generateInterpretBundle() {
     const usage = aggregator.getUsage();
     const usageHash = computeUsageHash(usage);
@@ -4040,30 +2495,7 @@ function hyperfixi(options = {}) {
     }
     return cachedBundle;
   }
-  function generateCompiledBundleCode() {
-    if (fallbackScripts.size > 0) {
-      if (options.debug) {
-        console.log(`[hyperfixi] ${fallbackScripts.size} scripts need interpreter fallback`);
-      }
-      return generateInterpretBundle();
-    }
-    const bundle = generateCompiledBundle({
-      handlers: compiledHandlers,
-      needsLocals,
-      needsGlobals,
-      globalName: options.globalName,
-      htmx: options.htmx,
-      debug: options.debug
-    });
-    if (options.debug) {
-      console.log(`[hyperfixi] Compiled bundle: ${compiledHandlers.length} handlers`);
-    }
-    return bundle;
-  }
   function generateBundle() {
-    if (mode === "compile") {
-      return generateCompiledBundleCode();
-    }
     return generateInterpretBundle();
   }
   return {
@@ -4141,20 +2573,6 @@ function hyperfixi(options = {}) {
       if (!scanner.shouldScan(id)) {
         return null;
       }
-      if (mode === "compile" && !isDev) {
-        const scripts = extractScripts(code);
-        for (const script of scripts) {
-          compileScript(script);
-        }
-        const result = transformHTML(code, handlerMap, fallbackScripts);
-        if (result.modified) {
-          if (options.debug) {
-            console.log(`[hyperfixi] Transformed: ${id.split("/").pop()}`);
-          }
-          return { code: result.code, map: null };
-        }
-        return null;
-      }
       const usage = scanner.scan(code, id);
       const changed = aggregator.add(id, usage);
       if (domainScanner && domainAggregator && domainScanner.hasAnyDomainUsage(code)) {
@@ -4208,17 +2626,6 @@ function hyperfixi(options = {}) {
      */
     async buildStart() {
       if (!isDev) {
-        if (mode === "compile") {
-          resetCompiler();
-          compiledHandlers.length = 0;
-          handlerMap.clear();
-          fallbackScripts.clear();
-          needsLocals = false;
-          needsGlobals = false;
-          if (options.debug) {
-            console.log("[hyperfixi] Compile mode: ready for build");
-          }
-        }
         const cwd = process.cwd();
         if (options.debug) {
           console.log("[hyperfixi] Scanning project for hyperscript usage...");
@@ -4244,22 +2651,6 @@ function hyperfixi(options = {}) {
             console.log("[hyperfixi] Domain build scan:", domainSummary);
           }
         }
-        if (mode === "compile") {
-          const usage = aggregator.getUsage();
-          if (usage.detectedLanguages.size > 0) {
-            const aliases = getMultilingualCommandAliases(
-              usage.detectedLanguages
-            );
-            if (Object.keys(aliases).length > 0) {
-              setMultilingualAliases(aliases);
-              if (options.debug) {
-                console.log(
-                  `[hyperfixi] Compile mode: configured ${Object.keys(aliases).length} multilingual aliases`
-                );
-              }
-            }
-          }
-        }
         if (options.debug) {
           const summary = aggregator.getSummary();
           console.log(`[hyperfixi] Found ${summary.fileCount} files with hyperscript:`, {
@@ -4284,17 +2675,14 @@ var index_default = hyperfixi;
   REGIONS,
   SUPPORTED_LANGUAGES,
   clearCustomKeywords,
-  clearSemanticParser,
   computeUsageHash,
   descriptorToScanRule,
   detectLanguages,
   getAllLanguageCodes,
   getKeywordsForLanguage,
   getOptimalRegion,
-  hasSemanticParser,
   hyperfixi,
   isNonLatinLanguage,
-  registerCustomKeywords,
-  setSemanticParser
+  registerCustomKeywords
 });
 //# sourceMappingURL=index.cjs.map