@lokascript/compilation-service 2.9.4 → 2.11.0

package/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.10.0] - 2026-08-01
+
+Full notes: [GitHub Releases](https://github.com/codetalcott/hyperfixi/releases/tag/v2.10.0).
+
+Highlights: `swap`/`process`/`morph … using view transition` across all 24
+languages (#870, #873, #875), typed command registration (#869, #871),
+`tell`/`process` parser fixes (#861, #872), the R1 role-fidelity burn-down
+(#864, #867, #868, #874, #878), and guards for the remaining hand-maintained
+CI package lists (#862, #865).
+
+## [2.9.0] - 2026-07-25
+
+> **Gap note:** 2.9.1 through 2.9.4 shipped without entries in this file; their
+> details live in [GitHub Releases](https://github.com/codetalcott/hyperfixi/releases).
+
 ### ⚠ BREAKING (types)
 
 - **Domain renderers return `string | null`.** `renderSQL`, `renderJSX`, `renderTodo`,
@@ -379,7 +394,12 @@ _Synchronized version release. See git history for details._
 - npm access token stored in GitHub Secrets
 - 2FA recommended for npm organization
 
-[Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v2.4.0...HEAD
+[Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v2.10.0...HEAD
+[2.10.0]: https://github.com/codetalcott/hyperfixi/compare/v2.9.0...v2.10.0
+[2.9.0]: https://github.com/codetalcott/hyperfixi/compare/v2.8.0...v2.9.0
+[2.8.0]: https://github.com/codetalcott/hyperfixi/compare/v2.5.1...v2.8.0
+[2.5.1]: https://github.com/codetalcott/hyperfixi/compare/v2.5.0...v2.5.1
+[2.5.0]: https://github.com/codetalcott/hyperfixi/compare/v2.4.0...v2.5.0
 [2.4.0]: https://github.com/codetalcott/hyperfixi/compare/v2.3.1...v2.4.0
 [2.3.1]: https://github.com/codetalcott/hyperfixi/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/codetalcott/hyperfixi/compare/v2.2.1...v2.3.0

package/dist/{chunk-MWUZGAKM.js → chunk-KWRIGXXK.js}

@@ -250,6 +250,9 @@ function generateSummary(trigger, opDiffs) {
   return parts.join(". ");
 }
 
+// src/scoring/score.ts
+import { scoreNodes } from "@lokascript/semantic/fidelity";
+
 // src/input/detect.ts
 function detectFormat(input) {
   const trimmed = input.trim();
@@ -2504,6 +2507,23 @@ function normalize(request) {
       return normalizeNatural(input, request.language ?? "en");
   }
 }
+function liftNodeDiagnostics(node, diagnostics) {
+  const nodeDiags = node.diagnostics;
+  if (!Array.isArray(nodeDiags)) return;
+  for (const d of nodeDiags) {
+    if (d.severity !== "warning" && d.severity !== "error") continue;
+    const diag = {
+      severity: d.severity,
+      // Parser codes are kebab-case; this surface uses UPPER_SNAKE (PARSE_ERROR &c).
+      code: (d.code ?? "PARSE_DIAGNOSTIC").replace(/-/g, "_").toUpperCase(),
+      message: d.message ?? "parser diagnostic"
+    };
+    if (d.code === "unconsumed-input") {
+      diag.suggestion = "Dropped tokens were parsed but bound to no role \u2014 usually a missing role marker (e.g. 'to'/'on'/'from' before the target), so the role fell back to a default like `me`. Compare the returned roles against your intent.";
+    }
+    diagnostics.push(diag);
+  }
+}
 function normalizeNatural(code, language) {
   const diagnostics = [];
   try {
@@ -2524,6 +2544,7 @@ function normalizeNatural(code, language) {
       });
       return { node: null, confidence: result.confidence, format: "natural", diagnostics };
     }
+    liftNodeDiagnostics(result.node, diagnostics);
     return {
       node: result.node,
       confidence: result.confidence,
@@ -2581,6 +2602,66 @@ function normalizeJSON(input) {
   };
 }
 
+// src/validation/inert-shapes.ts
+var QUANTIFIER = /^(all|every|each)\.(\S+)$/;
+var PREDICATE_AS_CLASS = /(^|\s)\.(has|is|contains|matches|includes)(\s|$)/;
+function valueString(v) {
+  return String(v.value ?? v.raw ?? "");
+}
+function checkInertShapes(node) {
+  const out = [];
+  walk(node, out);
+  return out;
+}
+function walk(node, out) {
+  if (!node || typeof node !== "object") return;
+  const n = node;
+  if (n.roles && typeof n.roles.entries === "function") {
+    for (const [role, raw] of n.roles.entries()) {
+      const v = raw ?? {};
+      const s = valueString(v);
+      const q = v.type === "expression" ? QUANTIFIER.exec(s) : null;
+      if (q && (role === "destination" || role === "source")) {
+        out.push({
+          severity: "warning",
+          code: "INERT_QUANTIFIER_TARGET",
+          message: `${role} parsed as property access "${s}" \u2014 "${q[1]}" is an undefined identifier at runtime, so this ${role} will not resolve.`,
+          suggestion: `Selectors already address every match: write the bare selector (e.g. ".${q[2]}") without "${q[1]}".`
+        });
+        continue;
+      }
+      if (role === "condition" && v.type === "expression" && PREDICATE_AS_CLASS.test(s)) {
+        const word = PREDICATE_AS_CLASS.exec(s)?.[2];
+        out.push({
+          severity: "warning",
+          code: "HALF_PARSED_CONDITION",
+          message: `condition parsed ".${word}" as a class selector (full condition: "${s}") \u2014 it will evaluate falsy and the body will never run.`,
+          suggestion: "For class tests use `matches`: `if #box matches .danger`."
+        });
+        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",
+          code: "INERT_PROPERTY_WRITE",
+          message: `set targets property "text" \u2014 on most elements this is not a DOM property, so the write usually changes nothing visible.`,
+          suggestion: 'Use `textContent` (`set the textContent of #el to \u2026`) or `put "\u2026" into #el`.'
+        });
+      }
+    }
+  }
+  if (Array.isArray(n.body)) for (const child of n.body) walk(child, out);
+}
+
 // src/validation/gates.ts
 var _validators = null;
 function initValidation(validators) {
@@ -2637,6 +2718,7 @@ function runValidationGates(node, confidence, confidenceThreshold) {
       }
     }
   }
+  diagnostics.push(...checkInertShapes(node));
   return { pass: true, diagnostics, adjustedConfidence };
 }
 function nodeToParseResult(node) {
@@ -2768,7 +2850,7 @@ var CompilationService = class _CompilationService {
     initValidation({
       validateSemanticResult: semantic.validateSemanticResult
     });
-    const aot = await import("./dist-FWHBOI2B.js");
+    const aot = await import("./dist-XER75XZI.js");
     const compiler = aot.createCompiler();
     initBridge(
       {
@@ -2891,9 +2973,17 @@ var CompilationService = class _CompilationService {
     }
     try {
       const result = this.translateFn(request.code, request.from, request.to);
+      let verification;
+      if (request.verify !== false) {
+        verification = this.scoreFidelity({
+          reference: { code: request.code, language: request.from },
+          candidate: { code: result, language: request.to }
+        });
+      }
       return {
         ok: true,
         code: result,
+        ...verification !== void 0 ? { verification } : {},
         diagnostics: []
       };
     } catch (error) {
@@ -3117,6 +3207,41 @@ var CompilationService = class _CompilationService {
       diagnostics
     };
   }
+  /**
+   * Score a candidate against a reference for structural fidelity — the
+   * multilingual ratchet's scorers (docs/FIDELITY.md) applied to one pair of
+   * inputs. Sides accept any input format and may be in different languages;
+   * see src/scoring/score.ts for signal semantics. Complementary to diff():
+   * diff answers "identical, and where not?", this answers "how faithful, and
+   * what exactly is missing or hallucinated?".
+   */
+  scoreFidelity(request) {
+    const diagnostics = [];
+    const threshold = request.confidence ?? this.confidenceThreshold;
+    const normRef = normalize({ ...request.reference, confidence: request.confidence });
+    diagnostics.push(
+      ...normRef.diagnostics.map((d) => ({ ...d, message: `[reference] ${d.message}` }))
+    );
+    const normCand = normalize({ ...request.candidate, confidence: request.confidence });
+    diagnostics.push(
+      ...normCand.diagnostics.map((d) => ({ ...d, message: `[candidate] ${d.message}` }))
+    );
+    if (!normRef.node || !normCand.node) {
+      return { ok: false, diagnostics };
+    }
+    const gateRef = runValidationGates(normRef.node, normRef.confidence, threshold);
+    const gateCand = runValidationGates(normCand.node, normCand.confidence, threshold);
+    diagnostics.push(
+      ...gateRef.diagnostics.map((d) => ({ ...d, message: `[reference] ${d.message}` }))
+    );
+    diagnostics.push(
+      ...gateCand.diagnostics.map((d) => ({ ...d, message: `[candidate] ${d.message}` }))
+    );
+    if (!gateRef.pass || !gateCand.pass) {
+      return { ok: false, diagnostics };
+    }
+    return { ok: true, diagnostics, ...scoreNodes(normRef.node, normCand.node) };
+  }
   /**
    * Generate a target-specific output from LSE (bracket syntax or protocol JSON).
    *
@@ -3316,6 +3441,7 @@ function nodeToSemanticJSON(node) {
 export {
   diffBehaviors,
   canonicalizeOp,
+  scoreNodes,
   detectFormat,
   SemanticCache,
   generateCacheKey,
@@ -3326,4 +3452,4 @@ export {
   SvelteRenderer,
   CompilationService
 };
-//# sourceMappingURL=chunk-MWUZGAKM.js.map
+//# sourceMappingURL=chunk-KWRIGXXK.js.map