@lokascript/compilation-service 3.3.0 → 4.0.0

package/CHANGELOG.md

@@ -7,6 +7,168 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.0.0] - 2026-10-04
+
+`@hyperfixi/core`'s own hyperscript engine is gone: its root re-exports `@hyperfixi/engine`, and
+its `hyperfixi.js` is the engine's 34 KB script-tag bundle where core's ~352 KB bundle used to be.
+The engine follows upstream `_hyperscript`'s grammar and is gated by upstream's own test suite, so
+scripts in core-only syntax need upstream's spelling (two additions stay: `new X()` and
+`toggle <element>`). Core's other bundles, its htmx layer, the core-era plugin packages and the
+AOT compiler retire: htmx 4 or fixi supply hypermedia attributes beside the engine, and
+`@lokascript/hyperscript-adapter` runs hyperscript written in other languages. Every package moves
+to 4.0.0 together. Everything under **Removed** is breaking, as is each **Changed** item marked ⚠;
+[MIGRATION.md](MIGRATION.md) names each replacement.
+
+### Removed
+
+- **Core's engine and its API** (#1368). These root exports had no engine counterpart:
+  `hyperscript` (`compile`, `compileSync`, `compileAsync`, `eval`, `validate`), `lokascript`,
+  `Runtime`, `RuntimeBase`, `createContext` and the element-scope helpers, `installPlugin`,
+  `getParserExtensionRegistry`, `setGlobal`, `DebugController`, `validatePartialContent` and its
+  helpers, `fromCoreAST` / `toCoreAST`. `parse` is now the engine's. The root is ESM-only, like the
+  engine: `dist/index.cjs` and the UMD `dist/index.min.js` (`LokaScriptCore`) are gone, though the
+  kept subpaths still ship CommonJS.
+- **21 of core's 29 entry points**: `/commands`, `/expressions`, `/parser/*`, `/behaviors`,
+  `/bundle-generator`, `/registry/*`, `/lse`, and `/browser/` `hybrid-complete`, `hybrid-hx`,
+  `hybrid-hx-v4`, `multilingual`, `modular` (#1343–#1368). Instead of `/commands`, import the
+  grammar modules from the root: `import { toggle } from '@hyperfixi/core'`.
+- **Core's browser bundles** (#1348, #1350, #1352, #1368): `hyperfixi-hx.js`,
+  `hyperfixi-hx-v4.js`, `hyperfixi-hybrid-complete.js`, `hyperfixi-multilingual.js`,
+  `hyperfixi-classic-i18n.js` and the code-split `hyperfixi.mjs`, plus every alias
+  (`hyperfixi-browser.js`, `hyperfixi-hybrid-hx.js`, each `lokascript-*.js`). Only
+  `hyperfixi.js` remains. CDN URLs pinned to 3.x keep working.
+- **Core's embedded htmx layer** (#1342, #1348, #1350): `hx-*` and fixi `fx-*` on core's runtime,
+  `hx-live`, `sse-connect` / `sse-swap`, `ws-connect` / `ws-send`. Load htmx 4 or fixi beside the
+  engine. `hx-live` becomes the engine's `live` block, and SSE and WebSockets are htmx 4's
+  `hx-sse` / `hx-ws`.
+- **Core-only members of `window.hyperfixi`**: `compile`, `compileSync`, `execute`, `setLocale`,
+  `evalLSENode`, `debugControl`, `semanticDebug`, the `hyperfixi:semantic-parse` event,
+  `hyperfixi:debug` logging, `_hyperscript.behaviors.resolve`, and the deprecated
+  `window.lokascript` (#1352, #1355).
+- **Core-only hyperscript syntax** (#1346, #1363, #1365). The engine rejects `has` / `have`,
+  `prepend`, `copy`, `push url` / `replace url`, `process partials`, the `pseudo` keyword, prefix
+  `unless`, bare `beep`, `a ? b : c`, core's `swap <strategy> of X with Y`, `set @a to v on X`,
+  `.debounce(n)` / `.throttle(n)`, `my?.x` and `tell X to …`. A few forms still parse but no longer
+  do what they did, such as `toggle .a on this` and `go forward`. MIGRATION.md gives each form's
+  upstream spelling. The multilingual reader still accepts them all.
+- **`@hyperfixi/core/multilingual`'s class API** (#1345, #1368): `MultilingualHyperscript` (with
+  `parseToAST`, `getAllTranslations`, …), `getMultilingual`, `multilingual`, `LanguageInfo`,
+  `schemaRoleInferrer`. The entry is three async functions: `parse`, `render`, `translate`.
+- **The AOT compiler** (#1364). Its output ran only on a runtime that was never published.
+  `@lokascript/compilation-service` loses `compile()`, `POST /compile`, `CompileResponse`, the
+  compile cache (`SemanticCache`, `getCacheStats`, `clearCache`, `/cache`), `generateTests`'
+  `executionMode` and `generate()`'s `'js'` target. `generate()` now requires `target`
+  (`react` | `vue` | `svelte` | `intent-element`). `@hyperfixi/mcp-server` loses
+  `compile_hyperscript`, `execute_lse`, `lse_to_hyperscript`'s `compile` option and
+  `generate_tests`' `executionMode`, leaving 106 tools. The loop is now `validate_and_compile`
+  (name kept), then repair, then the hyperscript as is in `_="…"`.
+- **`@hyperfixi/vite-plugin`'s compile mode** (#1360). `mode: 'compile'` warns and builds the
+  engine bundle. The exports `CompiledHandler`, `CompileOptions` and
+  `set/clear/hasSemanticParser` are removed.
+- **Smaller removals.** `@hyperfixi/core/reference` loses `availability`, `BundleAvailability`
+  and `getCommandsByAvailability` (#1363). `@hyperfixi/speech` loses `speechPlugin`,
+  `speakCommand`, `askCommand` and `answerCommand`; the engine has `ask` / `answer` (#1358).
+  `@hyperfixi/intent-element` loses its `evalLSENode` fallback (#1356).
+  `@hyperfixi/patterns-reference` loses four rows that held only retired htmx attributes, and
+  `hx-live-with-mutator` is renamed `live-with-handler` (#1348). Of the never-published VS Code
+  extensions, the LokaScript one loses its debugger and the standalone `_hyperscript` one is
+  retired (#1361).
+
+### Deprecated
+
+- **`@hyperfixi/reactivity`, `@hyperfixi/realtime`, `@hyperfixi/components`**: deprecated on npm,
+  last version 3.3.0 (#1358). Use the engine's built-in `live` / `when` / `bind`, htmx 4's
+  `hx-sse` / `hx-ws`, and upstream's component extension.
+- **`@hyperfixi/types-browser`'s `LokaScriptCoreAPI`**: a deprecated alias of `HyperfixiAPI`
+  (#1356).
+
+### Changed
+
+- ⚠ **`@hyperfixi/core` is the engine plus tooling** (#1368). The root is
+  `export * from '@hyperfixi/engine'` and `VERSION`: `register`, `everything` and each grammar
+  module, `api`, `parse`, `evaluate`, `processNode`, `boot`, and the AST types. The engine stays
+  external, so both packages share one grammar. Kept: `/multilingual`, `/ast-utils`,
+  `/reference`, `/metadata`, `/lsp-metadata`, `/browser`.
+- ⚠ **`hyperfixi.js` (`@hyperfixi/core/browser`) is the engine's `hyperfixi-hs.js`**, byte for
+  byte: 34 KB gzipped instead of ~352 KB (#1355). `window.hyperfixi` is `window._hyperscript`,
+  upstream-shaped (`evaluate`, `parse`, `process`, `use`, `config`, `addSourceTransform`). Parse
+  errors are a `hyperscript:parse-error` event on the element plus a `console.error` (#1354).
+- ⚠ **Runtime semantics follow upstream** wherever core's differed. `swap #a with #b` exchanges
+  the elements; `show` / `hide … with *opacity` honour the strategy; `tell` binds `you`, not `me`;
+  `set` on a selector sets every match; and `no ""` is true. MIGRATION.md has the full list.
+- ⚠ **`@hyperfixi/vite-plugin` emits a bundle on `@hyperfixi/engine`** (#1343). There is one
+  tier: the grammar modules the scan finds. It weighs 17.9 KB gzipped for three commands (3.x lite:
+  3.9 KB) and 34.4 KB for everything; 3.x fell back to 352 KB on `fetch`. htmx is not bundled.
+  Non-English scripts are translated as the engine reads them. `devFallback: 'everything'` is new,
+  and `'full'` / `'hybrid-complete'` mean the same. The plugin no longer depends on core.
+- ⚠ **`@hyperfixi/behaviors` runs on the engine** (peer `@hyperfixi/engine`; upstream works too).
+  Each behavior is defined with `host.evaluate(source)` and written in upstream's idioms.
+  Toggleable's `target` parameter is now `targetEl`. `LokaScriptInstance` / `LokaScriptWindow`
+  are now `HyperscriptHost` / `HyperscriptWindow` (#1338).
+- ⚠ **`@hyperfixi/speech` is an engine module** (#1358). Install it with
+  `register(...everything, speak)`. It is ESM-only and peers on the engine. `speak` takes
+  upstream's syntax (`speak <text> [with voice|rate|pitch|volume <x>]…`) and waits for the
+  utterance to end.
+- ⚠ **The localized htmx vocabulary moved** from `@hyperfixi/core/vocab/htmx/{lang}.js` to
+  `@lokascript/htmx-adapter/vocab/{lang}.js`; the data is unchanged (#1349).
+- **`@hyperfixi/intent-element`** renders an intent to English with the page's semantic bundle
+  and runs it through the host's `evaluate` (`NO_RENDERER` without one). It peers on
+  `@hyperfixi/engine` and `@lokascript/semantic` (#1339, #1356).
+- **`@lokascript/semantic` writes upstream's spelling in English** for core-only forms (#1346).
+  For example, `has` becomes `matches`, `prepend` becomes `put … at start of`, and swap strategies
+  become `put … into` / `before` / `after`. This reaches `translate(…, 'en')`,
+  `render(node, 'en')`, both adapters and MCP `translate_to_english`. In `fromSemanticAST`, a
+  handler's `then` chain is now its body (#1359).
+- **The language tools read the engine's parse** (#1356, #1359, #1365).
+  `@lokascript/language-server` and MCP `validate_hyperscript` report the engine's errors
+  (`source: 'engine'`). Hover and symbols come from `@lokascript/semantic`, and some long handlers
+  show fewer commands than in 3.x. Hyperscript mode flags exactly `new X()` and `toggle <element>`.
+  `@lokascript/compilation-service` rejects natural-language input the engine cannot read
+  (`ENGINE_PARSE_ERROR`), and its generated Playwright tests load `hyperfixi-hs.js`. The language
+  server, the MCP server and the compilation service now peer on `@hyperfixi/engine`.
+- **MCP**: `get_bundle_config` recommends `hyperfixi-hs.js`, plus an `adapter` field for
+  non-English. `analyze_complexity` / `analyze_metrics` no longer count every comparison as a
+  decision. The `debug_*` tools point to `log` and `breakpoint`. `UNSUPPORTED_QUERY_LITERAL` is
+  gone (#1350, #1352, #1359, #1361, #1364).
+- **`@hyperfixi/core/reference`, `/lsp-metadata`, `/metadata` describe the engine** (#1355,
+  #1363). They cover its 53 commands, adding `for`, `ask`, `answer` and `beep!`. Examples are in
+  upstream spelling and each is checked to parse; descriptions of core-only semantics (`pick`,
+  `beep`, `swap`) are fixed. `FEATURE_KEYWORDS` gains `install`, `when`, `live` and `bind`, and
+  `bundleInfo` holds one row.
+- **Dependencies.** `@lokascript/i18n`, `@hyperfixi/testing-framework`, `@hyperfixi/vite-plugin`,
+  `@hyperfixi/behaviors`, `@hyperfixi/speech` and `@hyperfixi/intent-element` no longer depend
+  on core. Core drops `@lokascript/intent`, morphlex, tslib and its optional peers. Versions are
+  lockstep, so upgrade `@hyperfixi/*` and `@lokascript/*` together. `@hyperfixi/mcp-server`,
+  `@lokascript/framework` (tests) and `@hyperfixi/server-bridge` (tests) range on
+  `@lokascript/domains ^3.0.1`, the first domains release whose peers accept framework,
+  semantic and intent 4.x (`^3.1.0 || ^4.0.0`).
+
+### Added
+
+- **`@hyperfixi/engine` exports `expr`**, so a grammar module can live in another package
+  (#1358).
+- **`@hyperfixi/core/ast-utils`'s `withEnginePositions`** gives interchange nodes the source
+  spans of the engine's parse (#1359).
+
+### Fixed
+
+- **`@hyperfixi/engine`** accepts upstream's `beep!` command (`beep! a, b`); 3.3.0 rejected it
+  (#1362).
+- **`@hyperfixi/types-browser`** types `window.hyperfixi` / `window._hyperscript` as the engine's
+  `HyperfixiAPI`. 3.3.0 re-exported a `./globals` it never emitted, so `window.hyperfixi` was
+  untyped (#1356).
+- **Semantic browser bundles** (#1351). Single-language and regional bundles (es, ja,
+  east-asian, …) registered no English, so the hyperscript adapter left scripts untranslated. They
+  now register it (+~2.2 KB gzipped) and export `translate`. The lite adapter finds any
+  `LokaScriptSemantic*` global.
+- **`@lokascript/semantic`** (#1338, #1343, #1347). `/core` plus a language module no longer
+  throws "No patterns registered". `on click from (x or me)` parses in th and zh. A `js … end`
+  block no longer ends its handler in ja / ko / hi / tr / qu / bn. An options object's `}` is no
+  longer read as an SOV event name.
+- **Language server and MCP** (#1359, #1363, #1365). `beep!` has hover docs. `set X to`
+  completions offer values. Hyperscript-mode errors land on the form, not line 0. Hover no longer
+  shows a second `on click`.
+
 ## [3.3.0] - 2026-10-02
 
 The first publication of `@hyperfixi/engine`, the hyperscript engine meant to replace the one

package/dist/{chunk-AMTQUPKJ.js → chunk-GWYYJAZY.js}

@@ -271,86 +271,6 @@ function detectFormat(input) {
   return "natural";
 }
 
-// src/compile/cache.ts
-var SemanticCache = class {
-  constructor(maxSize = 500) {
-    /** Cache hit/miss statistics */
-    this.hits = 0;
-    this.misses = 0;
-    this.maxSize = maxSize;
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Get a cached response, or undefined if not cached.
-   */
-  get(key) {
-    const entry = this.cache.get(key);
-    if (entry) {
-      this.hits++;
-      this.cache.delete(key);
-      this.cache.set(key, entry);
-      return entry;
-    }
-    this.misses++;
-    return void 0;
-  }
-  /**
-   * Store a response in the cache.
-   */
-  set(key, value) {
-    this.cache.delete(key);
-    if (this.cache.size >= this.maxSize) {
-      const oldest = this.cache.keys().next().value;
-      if (oldest !== void 0) {
-        this.cache.delete(oldest);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  /** Current cache size */
-  get size() {
-    return this.cache.size;
-  }
-  /** Clear all entries */
-  clear() {
-    this.cache.clear();
-    this.hits = 0;
-    this.misses = 0;
-  }
-};
-function generateCacheKey(node, options) {
-  const canonical = canonicalize(node);
-  const optKey = `${options.optimization ?? 2}:${options.target ?? "esm"}:${options.minify ?? false}`;
-  return `${canonical}|${optKey}`;
-}
-function canonicalize(node) {
-  if (!node || typeof node !== "object") return String(node);
-  const n = node;
-  const parts = [];
-  if (n.action) parts.push(`a:${n.action}`);
-  if (n.kind) parts.push(`k:${n.kind}`);
-  if (n.roles && typeof n.roles.entries === "function") {
-    const roles = n.roles;
-    const sortedRoles = [...roles.entries()].sort(([a], [b]) => a.localeCompare(b));
-    for (const [role, value] of sortedRoles) {
-      parts.push(`r:${role}=${canonicalizeValue(value)}`);
-    }
-  }
-  if (Array.isArray(n.body)) {
-    parts.push(`b:[${n.body.map(canonicalize).join(",")}]`);
-  }
-  if (n.eventModifiers && typeof n.eventModifiers === "object") {
-    const mods = Object.entries(n.eventModifiers).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}=${v}`).join(",");
-    if (mods) parts.push(`m:${mods}`);
-  }
-  return parts.join(";");
-}
-function canonicalizeValue(value) {
-  if (!value || typeof value !== "object") return String(value);
-  const v = value;
-  return `${v.type}:${v.value ?? v.raw ?? ""}`;
-}
-
 // src/operations/extract.ts
 function extractOperations(node) {
   const n = node;
@@ -759,16 +679,10 @@ var PlaywrightRenderer = class {
     lines.push("");
     lines.push(`test('${escapeString(testName)}', async ({ page }) => {`);
     lines.push(`  await page.setContent(\`${escapeTemplate(wrapHtml(html))}\`);`);
-    if (options.executionMode === "compiled" && options.compiledJs) {
-      lines.push(
-        `  await page.addScriptTag({ content: \`${escapeTemplate(options.compiledJs)}\` });`
-      );
-    } else {
-      const bundlePath = options.bundlePath ?? "./node_modules/@hyperfixi/core/dist/lokascript-browser.js";
-      lines.push(`  await page.addScriptTag({ path: '${escapeString(bundlePath)}' });`);
-      lines.push("  await page.waitForFunction(() => document.querySelector('[_]') !== null);");
-      lines.push("  await page.waitForTimeout(100);");
-    }
+    const bundlePath = options.bundlePath ?? "./node_modules/@hyperfixi/engine/dist/hyperfixi-hs.js";
+    lines.push(`  await page.addScriptTag({ path: '${escapeString(bundlePath)}' });`);
+    lines.push("  await page.waitForFunction(() => document.querySelector('[_]') !== null);");
+    lines.push("  await page.waitForTimeout(100);");
     lines.push("");
     const triggerLocator = getTriggerLocator(spec);
     for (const op of spec.operations) {
@@ -2651,15 +2565,6 @@ function walk(node, out) {
         });
         continue;
       }
-      if (v.type === "selector" && s.startsWith("<")) {
-        out.push({
-          severity: "warning",
-          code: "UNSUPPORTED_QUERY_LITERAL",
-          message: `${role} selector "${s}" uses query-literal syntax, which this parser does not support \u2014 at runtime it is an invalid CSS selector and matches nothing.`,
-          suggestion: `Use a plain CSS selector instead (e.g. "${s.replace(/^<|\/?>$/g, "")}").`
-        });
-        continue;
-      }
       if (n.action === "set" && v.type === "property-path" && v.property === "text") {
         out.push({
           severity: "warning",
@@ -2750,76 +2655,19 @@ function nodeToParseResult(node) {
   };
 }
 
-// src/compile/bridge.ts
-var _bridge = null;
-var _compiler = null;
-function initBridge(bridge, compiler) {
-  _bridge = bridge;
-  _compiler = compiler;
-}
-function compileSemanticNode(node, options = {}) {
-  if (!_bridge || !_compiler) {
-    throw new Error("Bridge not initialized. Call initBridge() first.");
-  }
-  const errors = [];
-  const warnings = [];
-  let semanticAST;
-  try {
-    const builder = new _bridge.ASTBuilder();
-    semanticAST = builder.build(node);
-    warnings.push(...builder.warnings);
-  } catch (error) {
-    errors.push(`AST build failed: ${error instanceof Error ? error.message : String(error)}`);
-    return { success: false, helpers: [], warnings, errors };
-  }
-  let interchangeAST;
-  try {
-    interchangeAST = _bridge.fromSemanticAST(semanticAST);
-  } catch (error) {
-    errors.push(
-      `Interchange conversion failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { success: false, helpers: [], warnings, errors };
-  }
-  try {
-    const result = _compiler.compileAST(interchangeAST, {
-      language: options.language ?? "en",
-      optimizationLevel: options.optimization ?? 2,
-      codegen: {
-        mode: options.target ?? "esm",
-        minify: options.minify ?? false
-      }
-    });
-    if (!result.success) {
-      return {
-        success: false,
-        helpers: [],
-        warnings: [...warnings, ...result.warnings],
-        errors: [...errors, ...result.errors ?? ["Compilation failed"]]
-      };
-    }
-    return {
-      success: true,
-      code: result.code,
-      helpers: result.metadata.runtimeHelpers,
-      warnings: [...warnings, ...result.warnings],
-      errors
-    };
-  } catch (error) {
-    errors.push(
-      `AOT compilation failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    return { success: false, helpers: [], warnings, errors };
-  }
-}
-
 // src/service.ts
 var CompilationService = class _CompilationService {
   constructor(options = {}) {
     this.translateFn = null;
     this.translationCollisionsFn = null;
+    /** semantic's `render`, for the English a translation runs as. */
+    this.renderFn = null;
+    /**
+     * `@hyperfixi/engine`'s first parse error for a source (null: it parses). Set by create()
+     * when the engine is installed (an optional peer); without it there is no engine check.
+     */
+    this.engineError = null;
     this.confidenceThreshold = options.confidenceThreshold ?? 0.7;
-    this.cache = new SemanticCache(options.cacheSize ?? 500);
     this.testRenderers = new Map(
       Object.entries(options.testRenderers ?? { playwright: new PlaywrightRenderer() })
     );
@@ -2848,8 +2696,8 @@ var CompilationService = class _CompilationService {
   /**
    * Create a CompilationService by dynamically importing dependencies.
    *
-   * This async factory resolves @lokascript/semantic and @hyperfixi/aot-compiler
-   * at runtime, following the same pattern as createMultilingualCompiler().
+   * This async factory resolves @lokascript/semantic (and, when it is installed,
+   * @hyperfixi/engine) at runtime.
    */
   static async create(options = {}) {
     const service = new _CompilationService(options);
@@ -2862,92 +2710,57 @@ var CompilationService = class _CompilationService {
     initValidation({
       validateSemanticResult: semantic.validateSemanticResult
     });
-    const aot = await import("./dist-6EMM5HXE.js");
-    const compiler = aot.createCompiler();
-    initBridge(
-      {
-        ASTBuilder: semantic.ASTBuilder,
-        fromSemanticAST: semantic.fromSemanticAST
-      },
-      compiler
-    );
     service.translateFn = semantic.translate;
     service.translationCollisionsFn = semantic.findTranslationCollisions;
+    service.renderFn = semantic.render;
+    try {
+      const engine = await import("@hyperfixi/engine");
+      engine.register(...engine.everything);
+      service.engineError = (source) => {
+        try {
+          return engine.api.parse(source).errors[0]?.message.split("\n")[0] ?? null;
+        } catch (e) {
+          return (e instanceof Error ? e.message : String(e)).split("\n")[0] ?? "parse error";
+        }
+      };
+    } catch {
+    }
     return service;
   }
-  // ===========================================================================
-  // Public API
-  // ===========================================================================
   /**
-   * Compile hyperscript to JavaScript.
-   *
-   * Accepts any of three input formats:
-   * - `code` + `language`: Natural language hyperscript
-   * - `explicit`: Bracket syntax [command role:value ...]
-   * - `semantic`: LLM JSON { action, roles, trigger }
-   *
-   * Returns compiled JS, semantic representation, and diagnostics.
+   * The engine's verdict on natural-language input: its parse of the English the page would
+   * run — the source as written, or a translation's English render (what
+   * `@lokascript/hyperscript-adapter` hands the engine). Null when it parses, or when there is
+   * nothing to check (explicit / JSON input, or no engine installed).
    */
-  compile(request) {
-    const diagnostics = [];
-    const normalized = normalize(request);
-    diagnostics.push(...normalized.diagnostics);
-    if (!normalized.node) {
-      return { ok: false, diagnostics };
-    }
-    const threshold = request.confidence ?? this.confidenceThreshold;
-    const gateResult = runValidationGates(normalized.node, normalized.confidence, threshold);
-    diagnostics.push(...gateResult.diagnostics);
-    if (!gateResult.pass) {
-      return {
-        ok: false,
-        confidence: gateResult.adjustedConfidence,
-        diagnostics
-      };
-    }
-    const cacheKey = generateCacheKey(normalized.node, {
-      optimization: request.optimization,
-      target: request.target,
-      minify: request.minify
-    });
-    const cached = this.cache.get(cacheKey);
-    if (cached) {
-      return {
-        ...cached,
-        confidence: gateResult.adjustedConfidence,
-        diagnostics: [...diagnostics, ...cached.diagnostics.filter((d) => d.severity !== "error")]
-      };
-    }
-    const result = compileSemanticNode(normalized.node, {
-      language: request.language,
-      optimization: request.optimization,
-      target: request.target,
-      minify: request.minify
-    });
-    for (const warning of result.warnings) {
-      diagnostics.push({ severity: "warning", code: "COMPILE_WARNING", message: warning });
-    }
-    for (const error of result.errors) {
-      diagnostics.push({ severity: "error", code: "COMPILE_ERROR", message: error });
-    }
-    if (!result.success) {
-      return { ok: false, diagnostics };
+  engineDiagnostic(request, normalized) {
+    if (!this.engineError || normalized.format !== "natural" || !request.code) return null;
+    const language = request.language ?? "en";
+    const english = language === "en" || language.startsWith("en-");
+    let source = request.code;
+    if (!english) {
+      if (!this.renderFn || !normalized.node) return null;
+      try {
+        source = this.renderFn(normalized.node, "en");
+      } catch {
+        return null;
+      }
     }
-    const semanticJSON = nodeToSemanticJSON(normalized.node);
-    const response = {
-      ok: true,
-      js: result.code,
-      helpers: result.helpers,
-      size: result.code ? new TextEncoder().encode(result.code).length : 0,
-      semantic: semanticJSON,
-      confidence: gateResult.adjustedConfidence,
-      diagnostics
+    const error = this.engineError(source);
+    if (!error) return null;
+    return {
+      severity: "error",
+      code: "ENGINE_PARSE_ERROR",
+      message: english ? `@hyperfixi/engine cannot read this: ${error}` : `@hyperfixi/engine cannot read its English (${source}): ${error}`,
+      suggestion: "The engine reads upstream _hyperscript's grammar: check the command's syntax (get_command_docs) and rewrite the part the error names."
     };
-    this.cache.set(cacheKey, response);
-    return response;
   }
+  // ===========================================================================
+  // Public API
+  // ===========================================================================
   /**
-   * Validate input without compiling.
+   * Validate input: semantic's parse and schemas, and (for natural-language input) the
+   * engine's parse of the English the page would run.
    * Returns semantic representation and diagnostics.
    */
   validate(request) {
@@ -2960,9 +2773,12 @@ var CompilationService = class _CompilationService {
     const threshold = request.confidence ?? this.confidenceThreshold;
     const gateResult = runValidationGates(normalized.node, normalized.confidence, threshold);
     diagnostics.push(...gateResult.diagnostics);
-    const semanticJSON = gateResult.pass ? nodeToSemanticJSON(normalized.node) : void 0;
+    const engineRejects = gateResult.pass ? this.engineDiagnostic(request, normalized) : null;
+    if (engineRejects) diagnostics.push(engineRejects);
+    const ok = gateResult.pass && !engineRejects;
+    const semanticJSON = ok ? nodeToSemanticJSON(normalized.node) : void 0;
     return {
-      ok: gateResult.pass,
+      ok,
       semantic: semanticJSON,
       confidence: gateResult.adjustedConfidence,
       diagnostics
@@ -3073,24 +2889,10 @@ var CompilationService = class _CompilationService {
       });
       return { ok: false, tests: [], operations: [], diagnostics };
     }
-    let compiledJs;
-    if (request.executionMode === "compiled") {
-      const compileResult = this.compile({
-        code: request.code,
-        explicit: request.explicit,
-        semantic: request.semantic,
-        language: request.language
-      });
-      if (compileResult.ok && compileResult.js) {
-        compiledJs = compileResult.js;
-      }
-    }
     const generated = renderer.render(spec, {
       testName: request.testName,
-      executionMode: request.executionMode,
       bundlePath: request.bundlePath,
-      hyperscript: request.code ?? request.explicit,
-      compiledJs
+      hyperscript: request.code ?? request.explicit
     });
     const semanticJSON = nodeToSemanticJSON(normalized.node);
     return {
@@ -3295,15 +3097,14 @@ var CompilationService = class _CompilationService {
    * Accepts LSE produced by an LLM (via `lse_generate_with_correction` MCP tool),
    * validates it, and renders to the requested target format.
    *
-   * Targets:
-   * - 'js'             — compiled JavaScript (default)
+   * Targets (`target` is required):
    * - 'react'          — React component
    * - 'vue'            — Vue component
    * - 'svelte'         — Svelte component
    * - 'intent-element' — HTML snippet with embedded `<lse-intent>` JSON
    */
   async generate(request) {
-    const { lse, target = "js", task } = request;
+    const { lse, target, task } = request;
     const diagnostics = [];
     const isJSON = lse.trimStart().startsWith("{");
     if (target === "intent-element") {
@@ -3389,44 +3190,28 @@ var CompilationService = class _CompilationService {
     const componentTargets = ["react", "vue", "svelte"];
     if (componentTargets.includes(target)) {
       const componentRequest = isJSON ? { semantic: JSON.parse(lse) } : { explicit: lse };
-      const result2 = this.generateComponent({
+      const result = this.generateComponent({
         ...componentRequest,
         framework: target
       });
       return {
-        ok: result2.ok,
-        output: result2.component?.code,
-        protocol: result2.semantic,
-        diagnostics: result2.diagnostics
+        ok: result.ok,
+        output: result.component?.code,
+        protocol: result.semantic,
+        diagnostics: result.diagnostics
       };
     }
-    const compileRequest = isJSON ? { semantic: JSON.parse(lse) } : { explicit: lse };
-    const result = this.compile(compileRequest);
     return {
-      ok: result.ok,
-      output: result.js,
-      protocol: result.semantic,
-      diagnostics: result.diagnostics
-    };
-  }
-  /**
-   * Get cache statistics.
-   */
-  getCacheStats() {
-    const total = this.cache.hits + this.cache.misses;
-    return {
-      size: this.cache.size,
-      hits: this.cache.hits,
-      misses: this.cache.misses,
-      hitRate: total > 0 ? this.cache.hits / total : 0
+      ok: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "UNKNOWN_TARGET",
+          message: `Unknown target '${String(target)}'. Available: react, vue, svelte, intent-element`
+        }
+      ]
     };
   }
-  /**
-   * Clear the compilation cache.
-   */
-  clearCache() {
-    this.cache.clear();
-  }
 };
 function extractSemanticValueString(v) {
   if (!v || typeof v !== "object") return "";
@@ -3494,8 +3279,6 @@ export {
   canonicalizeOp,
   scoreNodes,
   detectFormat,
-  SemanticCache,
-  generateCacheKey,
   extractOperations,
   PlaywrightRenderer,
   ReactRenderer,
@@ -3503,4 +3286,4 @@ export {
   SvelteRenderer,
   CompilationService
 };
-//# sourceMappingURL=chunk-AMTQUPKJ.js.map
+//# sourceMappingURL=chunk-GWYYJAZY.js.map