@hyperfixi/testing-framework 3.2.0 → 4.0.0

package/CHANGELOG.md

@@ -7,6 +7,206 @@ 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
+in `@hyperfixi/core`, and the example gallery moved onto it.
+
+### Added
+
+- **`@hyperfixi/engine` is published.** A hyperscript engine written against upstream
+  `_hyperscript`'s source, with upstream's own test suite as the acceptance oracle (1,401 of
+  1,467 tests; the 66 known failures are upstream's internal API, sockets and workers). It
+  ships `dist/hyperfixi-hs.js`, a script-tag bundle of hyperscript and nothing else, 34.1 KB
+  gzipped, which 36 of the repository's example pages now load instead of `hyperfixi.js`. It
+  keeps two forms upstream lacks, `new X(...)` and `toggle <element>`; the other hyperfixi-only
+  forms are not in it. It is typed (`tsc --strict`, no `any`), built from modules, and exposes
+  upstream's public API shape plus one hook, `addSourceTransform`, which
+  `@lokascript/hyperscript-adapter` uses to run the 24 languages on it.
+
+### Changed
+
+- **Examples and docs are written in upstream `_hyperscript`'s spelling** wherever upstream has
+  one: `put Y into X` for the `swap` strategies, `debounced at 300ms`, `matches`, `set X's @a`,
+  `increment #count's textContent` (core counted in a bare `#count`; upstream does not),
+  `on mutation of childList from #x`, `my offsetLeft` in place of `measure x`. The multilingual
+  reader still accepts the old forms; the renderer writes upstream's. Corpus rows follow.
+- **`@lokascript/semantic` renders `repeat for x in xs index i`** (was `with index`) and
+  `tell X show` (was `tell X to show`), upstream's spellings.
+- **The examples' bundle loader** takes a per-page default (`data-default="hs"`), and `?bundle=hs`
+  switches any page to the engine bundle.
+
+### Fixed
+
+- **`@hyperfixi/core`**: `toggle *display of X` parsed and then threw.
+- **Hybrid bundles (`hyperfixi-hx.js`)**: `increment` / `decrement` of a possessive wrote only
+  style properties; `increment #count's textContent` evaluated to the text and threw on
+  `querySelectorAll('0')`. They now write the property.
+- **`@lokascript/semantic`**: a template-literal URL in a Korean handler was read as a custom
+  event name.
+
 ## [3.2.0] - 2026-09-30
 
 A correctness release for multilingual hyperscript. The semantic parser behind
@@ -861,7 +1061,9 @@ _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/v3.1.0...HEAD
+[Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v3.3.0...HEAD
+[3.3.0]: https://github.com/codetalcott/hyperfixi/compare/v3.2.0...v3.3.0
+[3.2.0]: https://github.com/codetalcott/hyperfixi/compare/v3.1.0...v3.2.0
 [3.1.0]: https://github.com/codetalcott/hyperfixi/compare/v3.0.0...v3.1.0
 [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperfixi/testing-framework",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "description": "Cross-platform behavior testing suite for LokaScript applications",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,7 +29,7 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch",
-    "pretest": "../../scripts/ensure-fresh.sh ../intent ../framework ../semantic ../hyperscript-adapter ../patterns-reference ../core ../aot-compiler ../compilation-service",
+    "pretest": "../../scripts/ensure-fresh.sh ../intent ../framework ../semantic ../hyperscript-adapter ../engine ../patterns-reference ../compilation-service",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -41,7 +41,7 @@
     "typecheck": "tsc --noEmit",
     "test:check": "VITEST_TIMEOUT=240 VITEST_QUIET=1 bash ../../scripts/vitest-run.sh --reporter=dot",
     "test:canonical": "FOREIGN_CANONICAL_VALIDITY=1 VITEST_TIMEOUT=300 bash ../../scripts/vitest-run.sh --reporter=dot src/multilingual/canonical-validity.test.ts src/multilingual/foreign-canonical-validity.test.ts src/multilingual/render-fidelity.test.ts src/multilingual/bare-render-fidelity.test.ts src/multilingual/en-reference-preservation.test.ts",
-    "test:shipped-sources": "VITEST_TIMEOUT=300 bash ../../scripts/vitest-run.sh --reporter=dot src/multilingual/shipped-sources-validity.test.ts"
+    "test:shipped-sources": "VITEST_TIMEOUT=300 bash ../../scripts/vitest-run.sh --reporter=dot src/multilingual/shipped-sources-engine.test.ts src/multilingual/shipped-sources-localized.test.ts src/multilingual/shipped-examples-execution.test.ts"
   },
   "keywords": [
     "hyperscript",
@@ -57,11 +57,10 @@
   "author": "LokaScript Contributors",
   "license": "MIT",
   "dependencies": {
-    "@hyperfixi/core": "^3.2.0",
-    "@hyperfixi/patterns-reference": "^3.2.0",
-    "@lokascript/compilation-service": "^3.2.0",
-    "@lokascript/i18n": "^3.2.0",
-    "@lokascript/semantic": "^3.2.0",
+    "@hyperfixi/patterns-reference": "^4.0.0",
+    "@lokascript/compilation-service": "^4.0.0",
+    "@lokascript/i18n": "^4.0.0",
+    "@lokascript/semantic": "^4.0.0",
     "diff": "^8.0.3",
     "esbuild": "^0.25.12",
     "happy-dom": "^20.14.5",
@@ -73,7 +72,8 @@
     "vite": "^8.3.1"
   },
   "devDependencies": {
-    "@lokascript/hyperscript-adapter": "^3.2.0",
+    "@hyperfixi/engine": "^4.0.0",
+    "@lokascript/hyperscript-adapter": "^4.0.0",
     "@types/diff": "^5.0.0",
     "@types/node": "^26.6.3",
     "@vitest/coverage-v8": "^5.0.0",

package/src/agent-bench/README.md

@@ -138,7 +138,9 @@ class selector (`#box .has class .danger`) so the condition is always falsy;
 compilation-service validation pipeline (`validation/inert-shapes.ts`) matches
 those fingerprints and warns (`INERT_QUANTIFIER_TARGET`,
 `HALF_PARSED_CONDITION`, `UNSUPPORTED_QUERY_LITERAL`, `INERT_PROPERTY_WRITE`)
-— warnings only, still no parser change.
+— warnings only, still no parser change. (`UNSUPPORTED_QUERY_LITERAL` retired with
+the AOT compiler in 4.0: the engine reads query literals, and this benchmark,
+which executes on it since C4, scores `<body/>` correct.)
 
 |                                       | pre-3b      | after slice 1 | after slice 2          |
 | ------------------------------------- | ----------- | ------------- | ---------------------- |
@@ -153,6 +155,51 @@ parser-gap silent band is now zero.**
 Bands are computed by `harness.bandOf` — one function shared by the probe, the
 committed baseline, and the ratchet test, so they cannot drift apart.
 
+### Phase C4b: executed on the engine (2026-10-04)
+
+Execution moved from `@hyperfixi/core`'s runtime (fed semantic's parse through
+`buildAST`) to `@hyperfixi/engine`, the engine the product ships: the candidate
+is the button's `_` attribute, as on a page. Validation is unchanged
+(`CompilationService.validate`, semantic).
+
+|                                       | core runtime | engine         |
+| ------------------------------------- | ------------ | -------------- |
+| parse                                 | 36/37        | 36/37          |
+| behave correctly                      | 20/37        | **17/37**      |
+| wrong but **warned** (loop can react) | 14/37        | 12/37          |
+| wrong and **silent**                  | 2/37 (5%)    | **8/37 (22%)** |
+
+Four rows got better: core misbehaved on `add @aria-expanded="true" to`,
+`set the innerHTML of`, `set the style.backgroundColor of`, and `on "refresh"`
+(a quoted event name), all of which the engine runs as upstream does. Six got
+worse, and all six are the same kind: phrasings only core's lenient parser
+read — `and` between commands (two rows: `… and put …`, `remove … and add …`),
+`add .x on #item`, `put "x" in #el`, `toggle .active on this`, `toggle class
+.active` (and `, put …` warns). The engine rejects each, as upstream does, while
+the validator still says `ok`: they are silent because validation reads
+semantic's grammar, not the engine's. Phase C4d moves the diagnostics onto the
+engine's parse (owner decision 5), which should make all six visible.
+
+### Phase C4d: validated on the engine (2026-10-04)
+
+`CompilationService.validate` now also puts natural-language input to `@hyperfixi/engine`'s
+parser (the English as written, or a translation's English render), and a rejection is an
+error (`ENGINE_PARSE_ERROR`). Behavior is unchanged; what the loop can SEE changes:
+
+|                                       | C4b (semantic validator) | engine validator |
+| ------------------------------------- | ------------------------ | ---------------- |
+| parse (validator says ok)             | 36/37                    | **20/37**        |
+| behave correctly                      | 17/37                    | 17/37            |
+| wrong but **warned**                  | 12/37                    | 1/37             |
+| wrong and **rejected** (loop repairs) | 0/37                     | **16/37**        |
+| wrong and **silent**                  | 8/37                     | **3/37**         |
+
+Sixteen rows moved to `rejected`: eleven that only warned (the engine rejects what the
+inert-shape and unconsumed-input warnings described) and five of the six silent ones C4b
+measured. The three silent rows left are code the engine reads: `toggle .active on this`
+(`this` is a variable there, null at run time), and the valid-code-different-intent pair
+(`add .hidden to #menu`, `on mouseover`).
+
 ## Adding a task
 
 Append to [`tasks.ts`](./tasks.ts): a prompt with no hyperscript in it, a

package/src/agent-bench/agent-bench.test.ts

@@ -21,6 +21,13 @@
  * Deterministic and generator-free: no LLM runs here, so this IS a legitimate
  * CI gate (the A/B run in README.md, which needs a generator, deliberately is
  * not). Full sweep measures ~6s.
+ *
+ * @vitest-environment node
+ * Required, not a preference: candidates execute on @hyperfixi/engine in jsdom,
+ * and under the suite default (happy-dom) the DOM constructors already exist on
+ * globalThis, so the engine binds happy-dom's and every jsdom element fails its
+ * instanceof checks (measured: every reference produced no effect). Same reason
+ * as shipped-examples-execution.test.ts.
  */
 
 import { describe, it, expect, beforeAll } from 'vitest';

package/src/agent-bench/harness.ts

@@ -18,15 +18,19 @@
  * catch, so `parseRate` and `behaviorRate` are reported side by side and their
  * GAP is a headline number in its own right.
  *
- * Determinism: fresh JSDOM + fresh Runtime per execution, no network, no timers
- * beyond a fixed settle window. Effect-signature primitives are imported from
+ * Execution is `@hyperfixi/engine`, the product's engine: the candidate is the
+ * button's `_` attribute, as on a page. (Until Phase C4 it was `@hyperfixi/core`'s
+ * runtime, fed semantic's parse through `buildAST`.)
+ *
+ * Determinism: a fresh JSDOM per execution, no network, no timers beyond a
+ * fixed settle window. Effect-signature primitives are imported from
  * ../multilingual/effect-signature so this harness and the R2 ratchet can never
  * disagree about what a DOM effect is.
  */
 
 import { JSDOM } from 'jsdom';
-import { parseSemantic, buildAST } from '@lokascript/semantic';
 import { snapshot, diffSnapshots } from '../multilingual/effect-signature.js';
+import { installGlobals } from '../multilingual/shipped-examples-execution.js';
 import { SHARED_FIXTURE, type BenchTask } from './tasks.js';
 
 /** Settle window for the dispatched handler. No task waits/fetches. */
@@ -156,43 +160,29 @@ function buildDocument(task: BenchTask): JSDOM {
   return new JSDOM(`<!DOCTYPE html><html><body>${SHARED_FIXTURE}${task.fixture}</body></html>`);
 }
 
-function installGlobals(dom: JSDOM): void {
-  const g = globalThis as Record<string, unknown>;
-  g.window = dom.window;
-  g.document = dom.window.document;
-  g.Event = dom.window.Event;
-  g.CustomEvent = dom.window.CustomEvent;
-  g.HTMLElement = dom.window.HTMLElement;
-  g.Element = dom.window.Element;
-  g.Node = dom.window.Node;
-  g.MutationObserver = dom.window.MutationObserver;
-  g.getComputedStyle = dom.window.getComputedStyle;
+/** The engine's public surface this harness uses. */
+interface ScriptHost {
+  parse(source: string): { errors: Array<{ message: string }> };
+  processNode(node: unknown): void;
 }
 
-let core: {
-  Runtime: new () => { execute(ast: unknown, ctx: unknown): Promise<unknown> };
-  createContext: (el: HTMLElement) => unknown;
-} | null = null;
-
-let listenerErrors: string[] = [];
-let trapInstalled = false;
+let engine: ScriptHost | null = null;
 
-/** Bootstraps jsdom globals BEFORE loading core (its dist evaluates `Element`). */
+/** Bootstraps jsdom globals, then loads the engine with every module registered. */
 export async function initialize(): Promise<void> {
-  if (core) return;
+  if (engine) return;
   installGlobals(new JSDOM('<!DOCTYPE html><html><body></body></html>'));
-  const mod = (await import('@hyperfixi/core')) as unknown as {
-    Runtime: new () => { execute(ast: unknown, ctx: unknown): Promise<unknown> };
-    createContext: (el: HTMLElement) => unknown;
-  };
-  core = { Runtime: mod.Runtime, createContext: mod.createContext };
-  if (!trapInstalled) {
-    // Handler bodies are async, so a throw inside one surfaces as an unhandled
-    // rejection rather than propagating to our await.
-    process.on('unhandledRejection', (reason: unknown) => {
-      listenerErrors.push(reason instanceof Error ? reason.message : String(reason));
-    });
-    trapInstalled = true;
+  const mod = await import('@hyperfixi/engine');
+  mod.register(...mod.everything);
+  engine = mod.api;
+}
+
+/** The engine's first parse error for a source, first line; undefined when it parses. */
+function parseError(code: string): string | undefined {
+  try {
+    return engine!.parse(code).errors[0]?.message.split('\n')[0];
+  } catch (e: unknown) {
+    return (e instanceof Error ? e.message : String(e)).split('\n')[0];
   }
 }
 
@@ -203,22 +193,21 @@ async function executeInner(task: BenchTask, code: string): Promise<ExecutionOut
   const document = dom.window.document;
   task.setup?.(document);
   const btn = document.getElementById('btn')!;
-  listenerErrors = [];
 
-  // The runtime logs every failing command; across a full run that is noise.
+  // The engine reports a failing handler on the console (`hyperscript errors were
+  // found…`): record those, and drop the rest of the noise.
+  const runtimeErrors: string[] = [];
   const saved = { log: console.log, warn: console.warn, error: console.error };
-  console.log = console.warn = console.error = () => {};
+  console.log = console.warn = () => {};
+  console.error = (...args: unknown[]) => {
+    const error = args.find(a => a instanceof Error);
+    runtimeErrors.push(error instanceof Error ? error.message : String(args[0]));
+  };
   try {
-    const parsed = parseSemantic(code, 'en') as { node?: unknown; confidence?: number };
-    if (!parsed.node || (parsed.confidence ?? 0) < 0.5) {
-      return { effects: [], error: `parse failed (confidence ${parsed.confidence ?? 0})` };
-    }
-    const built = buildAST(parsed.node as never) as { ast?: unknown };
-    if (!built.ast) return { effects: [], error: 'buildAST returned no AST' };
-
-    const runtime = new core!.Runtime();
-    const ctx = core!.createContext(btn as unknown as HTMLElement);
-    await runtime.execute(built.ast, ctx);
+    const rejected = parseError(code);
+    if (rejected !== undefined) return { effects: [], error: `parse failed (engine: ${rejected})` };
+    btn.setAttribute('_', code);
+    engine!.processNode(btn);
 
     const before = snapshot(document);
     const trig = task.trigger ?? { event: 'click' };
@@ -232,8 +221,8 @@ async function executeInner(task: BenchTask, code: string): Promise<ExecutionOut
     await new Promise(r => setTimeout(r, SETTLE_MS));
 
     const effects = diffSnapshots(before, snapshot(document));
-    return listenerErrors.length > 0
-      ? { effects, error: `runtime: ${listenerErrors.join('; ')}` }
+    return runtimeErrors.length > 0
+      ? { effects, error: `runtime: ${runtimeErrors.join('; ')}` }
       : { effects };
   } catch (e: unknown) {
     return { effects: [], error: e instanceof Error ? e.message : String(e) };

package/src/multilingual/README.md

@@ -256,17 +256,22 @@ Add to `.github/workflows/test.yml`:
 (literal, variable, selector, possessive, `of`, dotted, call, array, parens), the
 operators, and five positions (`put` and `set` values, `if` and `repeat while`
 conditions, `increment … by`). Each cell's English runs on the real
-`hyperscript.org` engine, which is the oracle, and then in 48 lanes:
-
-| Lane     | What runs                                                                    |
-| -------- | ---------------------------------------------------------------------------- |
-| `en`     | hyperfixi's English path (core's parser and runtime)                         |
-| `en-rt`  | semantic's English parse, rendered back to English, on upstream              |
-| `<L>`    | each of 23 languages on hyperfixi's direct path                              |
-| `<L>/up` | the same translation, through `@lokascript/hyperscript-adapter`, on upstream |
-
-`baselines/value-matrix.json` lists every failing (cell, lane) pair; `*direct` and
-`*up` stand for all 23 lanes of each. The gate runs in five shards,
+`hyperscript.org` engine, which is the oracle, and then in 49 lanes:
+
+| Lane      | What runs                                                                    |
+| --------- | ---------------------------------------------------------------------------- |
+| `en`      | hyperfixi's English path (core's parser and runtime)                         |
+| `en-rt`   | semantic's English parse, rendered back to English, on upstream              |
+| `eng`     | the English source on `@hyperfixi/engine`                                    |
+| `<L>/up`  | each of 23 languages, through `@lokascript/hyperscript-adapter`, on upstream |
+| `<L>/eng` | the same adapter English on `@hyperfixi/engine`                              |
+
+The `<L>` lane (each language on core's direct path) retired in Phase C2 of the
+engine cutover, when text became the multilingual interchange; no cell failed
+`<L>/eng` while passing `<L>`.
+
+`baselines/value-matrix.json` lists every failing (cell, lane) pair; `*up` and
+`*eng` stand for all 23 lanes of each. The gate runs in fifteen shards,
 `value-matrix.<position>.test.ts`, and fails on a failing pair the baseline does not
 list and on a listed pair that passes, so the list only shrinks.
 
@@ -289,6 +294,20 @@ npx tsx tools/regen-value-matrix-baseline.ts --dry-run --results /tmp/matrix.jso
 A lane that fails in `en-rt` fails in nearly every translation: semantic's English
 parse lost the value, and every translation is rendered from it. Fix that first.
 
+## Direct-path shapes on the text path
+
+Core's `src/multilingual/*-direct-path.test.ts` files pin shapes core's direct path ran
+(an English source rendered into 23 languages, compiled with `{ language }` on core,
+installed in a fixture, triggered). That path retires with core's parser, so
+`direct-path-shapes.ts` runs the same 287 cases — extracted once into
+`direct-path-shapes.cases.json` — the way a page now runs a translation: the foreign
+text as written on `@hyperfixi/engine` with the adapter's plugin and `lang` on `<html>`.
+Upstream running the English is the oracle; where upstream rejects a core-only English
+source, upstream running the adapter's English is. Signatures are the body diff (text
+nodes normalized) plus a log of `fetch` / `history` / `window.open` / `scrollIntoView`
+calls. `KNOWN` lists the 4 failing cases with their reasons and only shrinks; the gate
+runs in three shards, `direct-path-shapes.<n>.test.ts`.
+
 ## Troubleshooting
 
 ### Bundle not found

package/src/multilingual/bare-render-fidelity.ts

@@ -14,7 +14,7 @@
  *
  * It matters because the bare form is a first-class public surface: MCP
  * `translate_code`, `hyperfixi.translate`/`getAllTranslations`, core's
- * `MultilingualHyperscript` and the VS Code "Show in my language" badge are all
+ * `multilingual` entry and the VS Code "Show in my language" badge are all
  * routinely handed a single command with no handler around it.
  *
  * WHAT IT ASSERTS

package/src/multilingual/cli.ts

@@ -25,7 +25,9 @@ const DIST_GUARD_PACKAGES = [
   'semantic',
   'i18n',
   'patterns-reference',
-  'core',
+  'hyperscript-adapter',
+  // The R2 execution validator's host since Phase C2 (core's left in C4).
+  'engine',
 ];
 
 /** True if any .ts under dir is newer than builtAt (early-exit walk). */
@@ -54,8 +56,8 @@ function findStaleDists(): string[] {
   for (const name of DIST_GUARD_PACKAGES) {
     const pkg = path.join(packagesRoot, name);
     const srcDir = path.join(pkg, 'src');
-    // Whichever entry the build emits: `.js` for most packages, `.mjs` for core
-    // (its CJS twin is `.cjs` — see scripts/ensure-fresh.sh).
+    // Whichever entry the build emits: `.js` for most packages, `.mjs` / `.cjs`
+    // for a dual build (see scripts/ensure-fresh.sh).
     const marker = ['index.js', 'index.mjs', 'index.cjs']
       .map(f => path.join(pkg, 'dist', f))
       .filter(f => fs.existsSync(f))

package/src/multilingual/direct-path-shapes-gate.ts

@@ -0,0 +1,56 @@
+/**
+ * The direct-path shapes gate (see direct-path-shapes.ts), in shards —
+ * `direct-path-shapes.<n>.test.ts` — so vitest runs them in parallel.
+ *
+ * Assertions, per shard:
+ *   1. every case not in KNOWN holds on the text path: upstream runs its
+ *      English, the engine runs that English the same way, and every
+ *      language's translation runs on the engine as upstream runs the English;
+ *   2. every KNOWN case still fails — prune one that passes, so the list only
+ *      shrinks;
+ *   3. (shard 0) every KNOWN id names a case.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import {
+  KNOWN,
+  caseFails,
+  describeFailure,
+  loadDirectPathCases,
+  runDirectPathShard,
+  type DirectPathResult,
+} from './direct-path-shapes';
+
+export const DIRECT_PATH_SHARDS = 3;
+
+export function describeDirectPathShard(shard: number): void {
+  describe(`direct-path shapes on the text path [${shard + 1}/${DIRECT_PATH_SHARDS}]`, () => {
+    let results: DirectPathResult[] = [];
+
+    beforeAll(async () => {
+      results = await runDirectPathShard(shard, DIRECT_PATH_SHARDS);
+      const pairs = results.reduce((n, r) => n + r.pairs.length, 0);
+      const failing = results.filter(caseFails).length;
+      console.log(
+        `direct-path shapes [${shard + 1}/${DIRECT_PATH_SHARDS}]: ${results.length} cases, ${pairs} translations, ${failing} failing case(s)`
+      );
+    }, 600_000);
+
+    it('every case not in KNOWN holds on the text path', () => {
+      expect(results.length).toBeGreaterThan(50);
+      const failing = results.filter(r => caseFails(r) && !(r.id in KNOWN));
+      expect(failing.map(describeFailure)).toEqual([]);
+    });
+
+    it('every KNOWN case still fails (prune one that passes)', () => {
+      const fixed = results.filter(r => r.id in KNOWN && !caseFails(r)).map(r => r.id);
+      expect(fixed).toEqual([]);
+    });
+
+    it('every KNOWN id names a case', () => {
+      if (shard !== 0) return;
+      const ids = new Set(loadDirectPathCases().map(c => c.id));
+      expect(Object.keys(KNOWN).filter(id => !ids.has(id))).toEqual([]);
+    });
+  });
+}

package/src/multilingual/direct-path-shapes.1.test.ts

@@ -0,0 +1,12 @@
+/**
+ * Direct-path shapes gate, shard 1 of 3. See direct-path-shapes.ts for what it
+ * runs and direct-path-shapes-gate.ts for the assertions.
+ *
+ * @vitest-environment node
+ * Required, not a preference: under happy-dom the engines bind happy-dom's
+ * DOM constructors, not the jsdom window's (see
+ * shipped-examples-execution.test.ts).
+ */
+import { describeDirectPathShard } from './direct-path-shapes-gate';
+
+describeDirectPathShard(0);