@lokascript/compilation-service 3.3.0 → 4.0.1

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