@hyperfixi/engine 7.2.0 → 7.4.0

package/CHANGELOG.md

@@ -7,6 +7,90 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.4.0] - 2026-10-21
+
+Content htmx or fixi swaps in runs its hyperscript, as it does on upstream `_hyperscript`: the
+engine has upstream's htmx integration in every bundle, and loading the engine twice no longer
+binds every handler twice. A minor: new behavior and a deprecated option, nothing removed.
+
+### Fixed
+
+- **`@hyperfixi/engine`: content htmx or fixi swaps in runs its hyperscript, and htmx content a
+  script puts in issues its requests.** Upstream `_hyperscript` has this integration in its core
+  runtime and the engine had none: a `_="on click …"` that htmx swapped in did nothing, and an
+  `hx-get` that a script `put` into the page was never wired. The engine now has upstream's
+  integration (0.9.93's `htmx-compat.js`), installed by `boot()` in every bundle, the Vite
+  plugin's included: `htmx:load` (htmx 2) and `htmx:after:process` (htmx 4) process the content,
+  an after-process hook hands what a script inserts to `htmx.process`, and on htmx 4 it
+  registers upstream's `hs-include` extension (`hs-include=":id"` sends element-scoped variables
+  with the request; `htmx.config.extensions = "hs-include"` enables it). Two additions upstream
+  lacks: fixi (`fx:swapped` processes the swapped content), and pages with their own hooks
+  between the two (`htmx.onLoad(el => _hyperscript.process(el))`,
+  `_hyperscript.addAfterProcessHook(el => htmx.process(el))`, the workarounds until now) no longer
+  recurse, where upstream recurses until the stack runs out. The workarounds can be removed. The
+  first vendoring of upstream's suite left out its htmx tests (`integration/htmx.js`,
+  `ext/hs-include.js`), which is how the gap shipped; the gate now runs them and passes all 19
+  (1422/1486). `hyperfixi-hs.js` grows 0.7 KB gzipped, to 34.9 KB.
+- **`@hyperfixi/engine`: loading the engine twice no longer binds every handler twice.** Element
+  state was private to each copy of the engine, so the second copy initialised every element
+  again and one click ran its handler twice. htmx 4's boosted swaps run body scripts again, so
+  boost, then back, did it on a page that loads the engine at the end of its body. The state is
+  now `elt._hyperscript`, where upstream keeps it and a second copy finds it (two more of
+  upstream's tests pass).
+- **Examples: sortable-list's Add Task added a blank task and threw.** Its script read the input
+  with `first #new-item-input`, which is null (`first` of one element), and now reads the element
+  itself. tell-command's code sample shows its `on click`.
+
+### Deprecated
+
+- **`@hyperfixi/vite-plugin`'s `htmx` option does nothing.** It added a listener for htmx 2's
+  event names, which htmx 4 does not fire; the engine's integration covers every bundle. The
+  option is still accepted, so existing configs build.
+
+## [7.3.0] - 2026-10-21
+
+`@hyperfixi/mcp-server` lists its 14 core tools by default and keeps the other 70 in toolsets
+that `LOKASCRIPT_MCP_TOOLSETS` lists, and five of its tools that were broken work. A minor, as
+when the sampling tools went opt-in (2.11.0): every tool still answers a call by name, and the
+variable lists any of them again.
+
+### Changed
+
+- **`@hyperfixi/mcp-server` lists 14 core tools by default; the other 70 are in opt-in
+  toolsets.** A connection listed all 84: about 13k tokens of definitions in each client that
+  loads them all, and a month of sessions called 7 of them. The default list is the agent loop
+  and what it leans on (`validate_and_compile`, `get_diagnostics`, `get_code_fixes`,
+  `get_command_docs`, `get_expression_docs`, `search_patterns`), translation (`translate_code`,
+  `translate_to_english`, `get_keyword_translations`, `list_supported_languages`), proof that
+  a change kept its meaning (`score_fidelity`, `diff_behaviors`), and `detect_domain` /
+  `compile_auto`: about 2.5k tokens. Set `LOKASCRIPT_MCP_TOOLSETS` to list more: `domains`
+  (26), `lse` (13), `grail` (5), `debug` (4), `editor` (3), `analysis` (9), `profiles` (5),
+  `project` (5), comma-separated, or `all`. Only the list changes: every tool still answers a
+  call by name. A client that picks tools from the list (Claude Code, Claude Desktop) needs
+  the variable to see a tool outside the core; the README lists each toolset's tools (#1607).
+
+### Fixed
+
+- **`lse_from_hyperscript` returned `[get patient:null]` for every input**, with `ok: true` and
+  confidence 1: it read the semantic parse as the AST builder's tree. It now renders the parse,
+  and refuses (`ok: false`, the rendered LSE under `partial`) a parse that left input unread or
+  a shape whose LSE does not parse back, such as a `then` chain inside a handler (#1607).
+- **`extract_routes` and `generate_server_routes` threw on every input** ("Cannot read
+  properties of undefined"), from the day they were added: they read `.routes` from the array
+  `scanRoutes` returns. They report server-bridge's route conflicts where they promised an
+  `errors` field it never had. The import that hid this from the typecheck (an untyped ambient
+  module) is gone (#1607).
+- **`get_code_fixes` had no fixes for the codes `validate_and_compile` emits**
+  (`ENGINE_PARSE_ERROR`, `UNCONSUMED_INPUT`, …), though the server's instructions send an agent
+  there from its diagnostics; `get_diagnostics`' `parse-error` and `low-confidence` mapped to
+  keys that did not exist. Every code compilation-service emits now has fixes, and a test holds
+  that (#1607).
+- **`explain_code` listed commands by kind, not in the order they run** (toggle → wait → add
+  came out "toggles … adds … waits") and dropped their targets. It explains the parse now: each
+  step rendered back to English with what it does, a block's body and an `if`'s two branches (#1607).
+- **`get_diagnostics`' typo fix was titled `Fix typo: ${suggestion}`**, unfilled, with no edit.
+  It now reads "Fix typo: toggle" with an edit that replaces the misspelled word (#1607).
+
 ## [7.2.0] - 2026-10-20
 
 `@hyperfixi/mcp-server` moves to `@lokascript/domains` 7.1.0: learn left the domains for

package/README.md

@@ -11,7 +11,7 @@ core's `dist/hyperfixi.js` is this package's `hyperfixi-hs.js`. It is also publi
 
 ## Install
 
-The script-tag bundle, hyperscript and nothing else (34.1 KB gzipped). It installs as
+The script-tag bundle, hyperscript and nothing else (34.9 KB gzipped). It installs as
 `window._hyperscript` and `window.hyperfixi`, and reads the document when it is ready:
 
 ```html
@@ -57,6 +57,20 @@ A script is rewritten as it is read. The element keeps the text its author wrote
 error in the rewritten script carries that text (`error.written`). `@lokascript/hyperscript-adapter`
 uses the hook when the host has it.
 
+### htmx and fixi
+
+Load htmx (2 or 4) or fixi beside any bundle and nothing else is needed: once the engine has
+processed the document it processes content they swap in, and hands htmx the content a script
+puts in, so its `hx-*` attributes work. On htmx 4 it registers upstream's `hs-include`
+extension (`hs-include=":userId"` sends an element-scoped variable with the request; enable it
+with `htmx.config.extensions = "hs-include"`). This is upstream's integration
+(`src/htmx-compat.ts`), with two additions: fixi (on `fx:swapped`), and a hand-off to htmx that
+does not recurse when a page also hands htmx's content to the engine itself
+(`htmx.onLoad(el => _hyperscript.process(el))`), as it does on upstream. As on upstream, the
+engine looks for htmx once, when it has processed the document: load htmx with a script tag
+(plain or `defer`, not `async`) for the hand-off and `hs-include`; swapped-in content is processed
+whenever htmx loads.
+
 ## Layout
 
 | File                                                             | What it holds                                                                                                                                                |
@@ -153,7 +167,7 @@ commands) 18.4 KB, `full` 34.1 KB, `core` (no commands) 13.8 KB.
 
 ## The script-tag bundle: `hyperfixi-hs.js`
 
-`dist/hyperfixi-hs.js` (minified, 34.1 KB gzipped; `hyperfixi-hs.dev.js` is the readable build) is the first product on this engine:
+`dist/hyperfixi-hs.js` (minified, 34.9 KB gzipped; `hyperfixi-hs.dev.js` is the readable build) is the first product on this engine:
 hyperscript and nothing else, every module, no htmx attributes, English only. It installs
 `window._hyperscript`, as upstream does, and the same object as `window.hyperfixi`. The name
 paired with core's `hyperfixi-hx.js` (hyperscript plus htmx, retired in Phase C3). Since C-R4b
@@ -185,8 +199,12 @@ gallery for `packages/core/test-pages/`. One behavior of core's is not in this e
 engine want `increment #count's textContent`. The examples write the second, which every
 bundle runs to the same count (the bundle matrix's Counter row).
 
-The 66 known failures: upstream's internal-API surface (`internals.tokenizer`,
-`evalStatically`, source info, error collection: 47), sockets and workers (17, upstream
+Since 2026-10-21 the gate also runs upstream's htmx tests (`integration/htmx.js` and
+`ext/hs-include.js`, 19), which the first vendoring left out, so the whole suite is 1,486. The
+engine failed 10 of them until it had upstream's htmx integration; it passes all 19.
+
+The 64 known failures: upstream's internal-API surface (`internals.tokenizer`,
+`evalStatically`, source info, error collection: 45), sockets and workers (17, upstream
 extensions that are not built), and two collection-expression tests that need upstream's
 component extension. Upstream's one failure is a test that expects its worker extension to be
 absent.

package/dist/common.js

@@ -37,13 +37,22 @@
     enter(_elt) {
     }
   };
-  var store = /* @__PURE__ */ new WeakMap();
-  var peekData = (elt) => store.get(elt);
-  var dropData = (elt) => store.delete(elt);
+  var windowHolders = /* @__PURE__ */ new WeakMap();
+  function holder(elt) {
+    if (elt.window !== elt) return elt;
+    let h = windowHolders.get(elt);
+    if (!h) windowHolders.set(elt, h = {});
+    return h;
+  }
+  var peekData = (elt) => holder(elt)._hyperscript;
+  function dropData(elt) {
+    const h = holder(elt);
+    const had = h._hyperscript !== void 0;
+    delete h._hyperscript;
+    return had;
+  }
   function dataOf(elt) {
-    let d = store.get(elt);
-    if (!d) store.set(elt, d = {});
-    return d;
+    return holder(elt)._hyperscript ??= {};
   }
   var rx = {
     /** True while an effect is evaluating: reads are then recorded as its dependencies. */
@@ -2400,6 +2409,108 @@
     };
   }
 
+  // src/htmx-compat.ts
+  var installed = /* @__PURE__ */ new WeakSet();
+  function installHtmxCompat(hs) {
+    if (installed.has(hs)) return;
+    installed.add(hs);
+    let fromHtmx = false;
+    const asHtmx = (f) => {
+      const was = fromHtmx;
+      fromHtmx = true;
+      try {
+        f();
+      } finally {
+        fromHtmx = was;
+      }
+    };
+    document.addEventListener(
+      "htmx:load",
+      (evt) => asHtmx(() => hs.process(evt.detail?.elt))
+    );
+    document.addEventListener("htmx:after:process", (evt) => asHtmx(() => hs.process(evt.target)));
+    document.addEventListener("fx:swapped", (evt) => {
+      const target = evt.detail?.cfg?.target;
+      hs.process(
+        target instanceof Element && target.isConnected ? target.parentElement ?? target : document.body
+      );
+    });
+    const htmx = Reflect.get(globalThis, "htmx");
+    if (typeof htmx?.process !== "function") return;
+    hs.addAfterProcessHook((elt) => {
+      if (!fromHtmx) asHtmx(() => htmx.process(elt));
+    });
+    if (htmx.version?.startsWith("4")) {
+      htmx.registerExtension?.("hs-include", {
+        htmx_config_request(elt, detail) {
+          const ctx = detail?.ctx;
+          if (!ctx) return;
+          const found = findHsInclude(ctx.sourceElement || elt);
+          if (!found) return;
+          const vars = resolveSpecifiers(found.value, found.scopeElt);
+          const body = ctx.request?.body;
+          if (body instanceof FormData) for (const k in vars) body.set(k, vars[k]);
+        }
+      });
+    }
+  }
+  function findHsInclude(sourceElt) {
+    const attr = sourceElt.getAttribute("hs-include");
+    if (attr !== null) return { value: attr, scopeElt: sourceElt };
+    for (let elt = sourceElt.parentElement; elt; elt = elt.parentElement) {
+      const inherited2 = elt.getAttribute("hs-include:inherited");
+      if (inherited2 !== null) return { value: inherited2, scopeElt: elt };
+    }
+    return null;
+  }
+  var readScope = (elt) => elt && peekData(elt)?.scopes?.elementScope || {};
+  function serialize(value) {
+    if (value == null) return "";
+    if (typeof value === "object") {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return "";
+      }
+    }
+    return String(value);
+  }
+  function resolveInherited(scopeKey, startElt) {
+    for (let elt = startElt; elt; elt = elt.parentElement) {
+      const scope = readScope(elt);
+      if (scopeKey in scope) return scope[scopeKey];
+    }
+    return void 0;
+  }
+  function resolveSpecifiers(attrValue, scopeElt) {
+    const result = {};
+    const raw = attrValue.trim();
+    if (raw === "*") {
+      const scope = readScope(scopeElt);
+      for (const k of Object.keys(scope)) result[k[0] === ":" ? k.slice(1) : k] = serialize(scope[k]);
+      return result;
+    }
+    for (let part of raw.split(",")) {
+      part = part.trim();
+      if (!part) continue;
+      if (part[0] === ":") {
+        const scope = readScope(scopeElt);
+        if (part in scope) result[part.slice(1)] = serialize(scope[part]);
+      } else if (part[0] === "^") {
+        const value = resolveInherited(":" + part.slice(1), scopeElt);
+        if (value !== void 0) result[part.slice(1)] = serialize(value);
+      } else if (part[0] === "#") {
+        const colon = part.lastIndexOf(":");
+        if (colon > 0) {
+          const scope = readScope(document.querySelector(part.slice(0, colon)));
+          const name = part.slice(colon + 1);
+          if (":" + name in scope) result[name] = serialize(scope[":" + name]);
+        }
+      }
+    }
+    return result;
+  }
+
   // src/parser.ts
   var ParseError = class extends Error {
     constructor(message, token, source, expected) {
@@ -2681,14 +2792,21 @@
   }
   var beforeProcess = [];
   var afterProcess = [];
+  var processing = /* @__PURE__ */ new Set();
   function processNode(node) {
     if (!(node instanceof Element || node instanceof Document || node instanceof DocumentFragment))
       return;
-    for (const hook of beforeProcess) hook(node);
-    const selector = attributes().map((a) => `[${a}]`).join(", ") + ", [type='text/hyperscript']";
-    if (node instanceof Element && node.matches(selector)) initElement(node);
-    node.querySelectorAll(selector).forEach(initElement);
-    for (const hook of afterProcess) hook(node);
+    if (processing.has(node)) return;
+    processing.add(node);
+    try {
+      for (const hook of beforeProcess) hook(node);
+      const selector = attributes().map((a) => `[${a}]`).join(", ") + ", [type='text/hyperscript']";
+      if (node instanceof Element && node.matches(selector)) initElement(node);
+      node.querySelectorAll(selector).forEach(initElement);
+      for (const hook of afterProcess) hook(node);
+    } finally {
+      processing.delete(node);
+    }
   }
   function cleanup(elt) {
     const data = peekData(elt);
@@ -2734,7 +2852,7 @@
     cleanup,
     /** The part of upstream's `internals` that pages and tests reach for. */
     internals: { runtime: { cleanup, processNode } },
-    version: false ? "dev" : "7.2.0"
+    version: false ? "dev" : "7.4.0"
   });
   function boot() {
     Object.assign(globalThis, { _hyperscript: api });
@@ -2742,6 +2860,7 @@
     const start = () => {
       processNode(document.documentElement);
       document.dispatchEvent(new Event("hyperscript:ready"));
+      installHtmxCompat(api);
     };
     if (document.readyState === "loading") document.addEventListener("DOMContentLoaded", start);
     else setTimeout(start);