@hyperfixi/testing-framework 4.0.0 → 4.1.0

package/CHANGELOG.md

@@ -7,6 +7,186 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.1.0] - 2026-10-06
+
+Translations keep what the source says. `tell` blocks, swaps, view transitions, chains of
+handlers without their `end`s, events with names of several words, and variables named like
+events or keywords now survive `translate`, MCP `translate_code` and the adapter in every
+language. The adapter's per-language bundles render English with semantic's renderer, and
+`@lokascript/semantic/core` gains `registerHandcrafted`.
+
+### Added
+
+- **`@lokascript/semantic` reads upstream's `start view transition … end`, in all 24 languages.**
+  `on click start view transition swap #a with #b end` parsed as a `transition` command whose
+  patient was `swap`, so `translate`, MCP `translate_code` and the corpus lost the block and its
+  body (`on click transition swap`), and validation reported the rest as unconsumed input. The
+  block is now a `viewTransition` command with its `body` (`ViewTransitionSemanticNode`;
+  `isViewTransitionBlock` from the package root), nested the way a loop's body is: a command after
+  the block's `end` stays after it, and the `end` no longer closes the handler, behavior or `def`
+  around it. `start [a] view transition [using "<type>"]` is written in English in every language,
+  as core's `using view transition` tail already is (a browser API's name, which no profile
+  translates). The corpus row `swap-view-transition` is now written this way and parses on both
+  engines.
+
+### Changed
+
+- **Single-language bundles hold only their own language's hand-crafted patterns.** Each
+  command's pattern dispatcher in `@lokascript/semantic` named all 24 languages' hand-crafted
+  patterns, so every bundle that could build patterns held all of them (~200 KB minified). Each
+  language module now registers its own (`src/patterns/handcrafted/<lang>.ts`, through
+  `@lokascript/semantic/core`'s new `registerHandcrafted`), and bundlers drop the rest:
+  semantic's single-language bundles are 14–15 KB gzipped smaller (`browser-de` 116 KB instead
+  of 130), and a Vite or Rollup build that imports `@lokascript/semantic/core` and one
+  `languages/<lang>` gets the same saving. The patterns each language builds are unchanged
+  (hashed for all 24 before and after, from source and from the split `dist/`). The adapter's
+  bundles, which also changed renderer in this release, are measured in its entry under Fixed.
+
+### Fixed
+
+- **`@lokascript/semantic`: a variable named like an event or a keyword keeps its name.** Upstream
+  and the engine run `set input to "a"` on a variable named `input`, but semantic's English parse
+  dropped the whole command (an event name alone took the value as the text "input", which a
+  `set` cannot write), so `translate`, MCP `translate_code` and the adapter lost it in every
+  language; `put "a" into input` was lost in ar, de, fr, id and zh, whose tokenizers read `input`
+  as the event, and `toggle .a on input` in six. An event name alone where a value stands is now
+  the variable it spells, as a structure word or a verb already was, except where an event stands
+  (`send`, `trigger`, `repeat until event`, `wait`). And the renderer no longer writes a variable
+  in the language's own word where that word reads back as another variable: `set when to 1`
+  wrote es `establecer cuando a 1`, read back as a variable named `cuando`, in all 23 languages,
+  and bn, ms, th and tl wrote `increment i by index` with their word for `index`. A variable keeps
+  its localized word only where that word alone is the same value (es `ello` for `it`), and the
+  verified render spells one whose neighbours change it (vi `đặt giá trị`, `set`, for `put value`).
+  The value matrix now runs ten such names (`input`, `click`, `when`, `index`, …) in every
+  position: all pass on both engines. No corpus row changes.
+- **`@lokascript/semantic`: the event a command names reads back in every language, and a
+  `wait` keeps its source for any event.** The handler head read a native event name through the
+  event table, but `send`, `trigger` and `repeat until event` read it only when the language's
+  tokenizer knew the word: es `enviar dobleclic a #x` read back `send dobleclic to #x`, so the
+  event fired as `dobleclic` (55 of the 170 localized names per command: es, pt, fr, de, ko and zh
+  coinages, and id and sw `unload`). They now read it as its English name, as the head does. A `wait` kept the source of an
+  event only from a fixed list, in English first: `wait for myEvent from #b`,
+  `wait for unload from #b` and `wait for focusin from window` lost the source in every language, and
+  `wait for click or myEvent from #b` everything after `click`. Upstream reads every leg of
+  `wait for` that is not a number as an event, so English now does, and a name followed by a
+  source is an event in every language (a time wait has none); tr and tl no longer read `focusin`
+  as `focus`. bn writes the event `send` sends with `কে`, as `trigger`'s, since
+  `#x তে স্ক্রোল তে পাঠান` read as `scroll to #x`; the old `তে` still reads. And fr's `change`
+  event, `changement`, no longer reads as the reactive `when … changes` word, which turned
+  `repeat until event change` into a `when` feature. Four corpus rows change, the bn renders of
+  `send` (`কে` for `তে`).
+- **`@lokascript/semantic`: a hand-written event name of several words is read whole.** The event
+  table reads 20 names of several words that the renderer never writes (ar `تمرير الماوس`, de
+  `taste runter`, id `lepas tombol`, pt `pressionar tecla`, qu `mana q'away`, sw `bonyeza chini`,
+  tr `fare_bas`, zh `鼠标进入`, and twelve more), but their tokenizers split them, and the reader took
+  the first word for the event: de `wenn taste runter protokollieren 1` read `on taste log 1`, id
+  `ketika lepas tombol …` `on lepas`, sw `unapo bonyeza chini …` `on click`, qu
+  `maykama mana q'away …` `on false`, and ar `على تمرير الماوس من #b …` `on scroll`. A `wait for`,
+  `send`, `trigger` or `repeat until event` lost the event the same way. The tokenizers now read
+  each name whole; tr reads an `_`-joined word as one token when it is a keyword, as sw already did
+  (its own `tuş_bas` had never been read), and splits any other at `_` as before. No corpus row
+  changes.
+- **`@lokascript/semantic`: an event name of several words keeps what is written after it.** ar
+  writes keydown, keyup and resize as `ضغط المفتاح`, `رفع المفتاح` and `تغيير حجم`, id writes
+  keydown as `tekan tombol`, and vi writes resize as `đổi kích thước`, but each tokenizer read only
+  the first word as the event. So `on keyup from #b log 1` read back `on keyup log 1` in ar,
+  `on resize from window` read back `on change` in ar and vi, and `send keyup to #x`,
+  `trigger keydown on #x`, `repeat until event keyup from #b` and `wait for resize` lost their
+  `to`, `on` or `from`, or waited for `change`. `translate`, MCP `translate_code` and the adapter
+  carried the loss. The three tokenizers now read each name whole, as es, fr, pt and qu already
+  did. The corpus's ar and vi `window-resize` rows, which the parser's compound repair already
+  read right, now parse at full confidence (1.0, was 0.82); no other corpus row changes.
+- **`@lokascript/semantic`: a behavior's handlers need no `end` of their own.** Upstream ends a
+  handler's commands at the next feature, so `behavior F on click add .a on keyup log 1 end end`
+  is two handlers. The behavior parser split its body only at `end`, read both handlers as one,
+  and English wrote `behavior F then add .a then log 1`, which the engine rejects: `translate`,
+  MCP `translate_code` and the adapter broke such a behavior in every language. Each piece now goes
+  through the splitter a top-level chain of handlers already used, and parses to the same node as
+  the form with every `end` written. No corpus row changes (every one writes its `end`s).
+- **`@lokascript/semantic`: a chain of handlers written natively without their `end`s reads as
+  written, in every language.** In 9 languages such a chain merged into one handler, at top level
+  and inside a behavior, and the result was valid English that ran wrong: de, fr, id, zh, ko, qu
+  and tr dropped the second event and ran its commands on the first (`on click add .a then log
+1`), and hi and bn read it as a destination (`add .a to keyup`). The split knew a handler head
+  only as `on`'s forms and ja/ko's `を で` / `을 에`; it now reads each language's own: the `when`
+  word the renderer writes (de `wenn`, fr `quand`, id `ketika`, qu `maykama`), zh's `一 … 就`, and
+  the words after the event (ko `할 때`, tr `i üzerinde`). The same rule ends an `init` with no
+  `end` in SOV languages too, and he and vi no longer read a handler after `toggle .a on #x` as the
+  toggle's. hi `पर` and bn `তে` are also the destination marker, which almost every command there
+  may write first, so a split at one is never trusted: it reads as written, at a confidence below
+  the adapter's threshold, so the adapter leaves the script as written and the engine reports it.
+  No corpus row changes.
+- **`@lokascript/semantic`: English writes core's view-transition tail as upstream's block.**
+  `swap #a with #b using view transition` (and `morph`'s tail) renders to English as
+  `start view transition swap #a with #b end`, which upstream _hyperscript and `@hyperfixi/engine`
+  both parse; the tail itself is rejected by both. Every language reads the tail, and
+  `@lokascript/hyperscript-adapter` hands the host the English render, so a page written in
+  another language with a view-transition swap failed to parse and ran nothing. Foreign renders
+  keep the tail.
+- **`@lokascript/semantic`: a `swap` keeps both operands in every language.** Only a swap of two
+  selectors round-tripped. `swap #target with me`, `swap :x with :y` and a swap of properties
+  (`swap my textContent with #a`, `swap #a's textContent with #b's textContent`) lost an operand
+  or its property in up to 21 languages, so a translated page swapped the wrong thing or nothing.
+  Four causes: swap's roles took no reference or property path; a handler's repair re-parse was
+  vetoed when the swap's first operand moved to its real role; an optional slot that declined a
+  value by type still consumed it (any command's pattern could lose the next role that way); and
+  in pl/uk the with-word is also the of-word, so `swap el with #t` read as `#t's el`.
+- **`@lokascript/semantic`: a `tell` block keeps its extent.** Semantic kept `tell` flat, its body
+  being every statement after it, so in English and every translation a command after the tell's
+  `end` was lost (`tell #modal show end then log 2` lost the `log`) or pulled inside it
+  (`… end log 2`), a nested tell took its parent's remaining commands, and in a behavior or `def`
+  the tell's `end` closed the enclosing block, dropping the next handler or command. The parser
+  now nests a tell's body as it nests a loop's (`BlockCommandSemanticNode`, `isBlockCommand`), and
+  reads an `end` as the tell's exactly when the engine does: before a new `on <event>`, `def`,
+  `init` or `behavior`, a tell needs none.
+- **`@lokascript/hyperscript-adapter`'s per-language and regional bundles render English with
+  semantic's renderer.** They rendered with their own English writer, which saved English's
+  language data and had drifted far from semantic's: over the corpus's 3,772 translations, 1,242
+  rendered to valid English that did something else, and 345 to English the engine rejects (the
+  script then kept its author's text and did not run). Every `if` lost its branches,
+  `put … before`/`after` became `put … into`, `from window`, `from elsewhere`, `debounced` and
+  `or <event>` vanished, `<button/> in me` widened to the whole page, `repeat for x in …` lost
+  its binding, and every `swap #a with #b` was written `swap of #a with #b`. They now give exactly
+  what the full `hyperscript-i18n.global.js` gives. English's own module builds through
+  `@lokascript/semantic/core` (its pattern generator and repeat heads,
+  `getRepeatPatternsForLanguage` now exported there), so a bundle holds one copy. Against 4.0.1,
+  the single-language bundles are the same size (`-de` 116 KB gzipped) and `-en` is 109 KB
+  instead of 148; the regional bundles are 8–16 KB larger (`western` 141 KB instead of 125).
+
+## [4.0.1] - 2026-10-05
+
+Fixes for 4.0.0: the per-language adapter bundles read every language again, and the MCP server's
+documentation and core's metadata describe the 4.0 engine.
+
+### Fixed
+
+- **`@lokascript/hyperscript-adapter`: the self-contained per-language and regional bundles read
+  German, French, Quechua and Chinese again.** `hyperscript-i18n-<lang>.global.js` and the regional
+  bundles installed a generate-only pattern generator over the one `@lokascript/semantic/core`
+  provides, discarding its hand-crafted patterns: in de, fr, qu and zh even
+  `on click toggle .active` stayed untranslated (the host then rejected it), and other languages
+  lost shapes such as `toggle … on #target`; 1106 of the corpus's 3772 translations read
+  differently from the full package. Published 3.x and 4.0.0 bundles alike; the all-languages
+  `hyperscript-i18n.global.js` was unaffected. The bundles now keep `/core`'s generator (sizes
+  unchanged: the ~23 KB 4.0.0 added was this generator, unused until now). Their English renderer
+  also drops only an implicit `me` now, so `put "x" into me` no longer renders as the
+  engine-invalid `put "x"` in every language. New gate: every built bundle runs translated
+  handlers on the engine (`test/adapter-iife.test.ts`).
+- **`@hyperfixi/mcp-server`'s documentation resources teach upstream's spelling.**
+  `hyperscript://docs/commands`, `/expressions`, `/events` and `hyperscript://examples/common` still
+  taught core 3.x: `on submit.prevent`, `on input.debounce(300ms)`, `on keydown.enter`,
+  `swap #t innerHTML`, `while …`, a bare `[attr]` selector, a `parent` keyword, `you` as the event
+  target. The engine rejects those, or reads them as something else (`on click.prevent` listens for
+  an event named `click.prevent`). A test now parses every example on the engine. The repo's
+  `hyperfixi-developer` skill, generated from them, follows (`generate:skills` had been writing to
+  the wrong directory).
+- **`@hyperfixi/core/metadata` describes 4.0.** `packageInfo.description` still said "Modern
+  hyperscript engine with fixi/htmx integration" and `compatibility` "~85% official _hyperscript",
+  both 3.x claims. `packageInfo.upstreamSuite` (`{ version, passed, total }`) now publishes the
+  engine's result on upstream _hyperscript's own test suite (1401 of 1467 in 0.9.93), and
+  `compatibility` is derived from it; `verify:reference` fails when it disagrees with
+  `packages/engine/upstream-suite/known-failures.json`. `ecosystem` drops "212 LLM examples".
+
 ## [4.0.0] - 2026-10-04
 
 `@hyperfixi/core`'s own hyperscript engine is gone: its root re-exports `@hyperfixi/engine`, and
@@ -1061,7 +1241,10 @@ _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.3.0...HEAD
+[Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v4.1.0...HEAD
+[4.1.0]: https://github.com/codetalcott/hyperfixi/compare/v4.0.1...v4.1.0
+[4.0.1]: https://github.com/codetalcott/hyperfixi/compare/v4.0.0...v4.0.1
+[4.0.0]: https://github.com/codetalcott/hyperfixi/compare/v3.3.0...v4.0.0
 [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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperfixi/testing-framework",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Cross-platform behavior testing suite for LokaScript applications",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -57,10 +57,10 @@
   "author": "LokaScript Contributors",
   "license": "MIT",
   "dependencies": {
-    "@hyperfixi/patterns-reference": "^4.0.0",
-    "@lokascript/compilation-service": "^4.0.0",
-    "@lokascript/i18n": "^4.0.0",
-    "@lokascript/semantic": "^4.0.0",
+    "@hyperfixi/patterns-reference": "^4.1.0",
+    "@lokascript/compilation-service": "^4.1.0",
+    "@lokascript/i18n": "^4.1.0",
+    "@lokascript/semantic": "^4.1.0",
     "diff": "^8.0.3",
     "esbuild": "^0.25.12",
     "happy-dom": "^20.14.5",
@@ -72,8 +72,8 @@
     "vite": "^8.3.1"
   },
   "devDependencies": {
-    "@hyperfixi/engine": "^4.0.0",
-    "@lokascript/hyperscript-adapter": "^4.0.0",
+    "@hyperfixi/engine": "^4.1.0",
+    "@lokascript/hyperscript-adapter": "^4.1.0",
     "@types/diff": "^5.0.0",
     "@types/node": "^26.6.3",
     "@vitest/coverage-v8": "^5.0.0",

package/src/multilingual/value-matrix.names.test.ts

@@ -4,7 +4,7 @@
  * leaves out; the matrix shards run the names themselves.
  */
 import { describe, it, expect } from 'vitest';
-import { collidingNames, generateCells } from './value-matrix';
+import { KEYWORD_NAMES, collidingNames, generateCells } from './value-matrix';
 
 const names = new Map(collidingNames().map(entry => [entry.name, entry]));
 
@@ -29,6 +29,16 @@ describe('value matrix: colliding names', () => {
     expect(names.has('an')).toBe(true);
   });
 
+  // Upstream runs each as a variable; English's own parse dropped `set input
+  // to "a"`, and every language wrote `when` as its keyword (P49).
+  it('takes the English words upstream runs as variables (KEYWORD_NAMES)', () => {
+    for (const name of KEYWORD_NAMES) expect(names.has(name), name).toBe(true);
+    expect(KEYWORD_NAMES).toContain('input'); // an event name
+    expect(KEYWORD_NAMES).toContain('when'); // a structure word
+    expect(KEYWORD_NAMES).toContain('index'); // a value-lexicon word (P28)
+    expect(names.has('if')).toBe(false); // P53
+  });
+
   it("leaves out upstream's `no` and the templates' variables", () => {
     expect(names.has('no')).toBe(false);
     expect(names.has('i')).toBe(false);

package/src/multilingual/value-matrix.ts

@@ -550,6 +550,30 @@ let collidingNamesMemo: readonly CollidingName[] | undefined;
  */
 const CODE_NAMES: readonly string[] = ['userData'];
 
+/**
+ * Names spelled like English vocabulary that upstream and the engine run as
+ * variables where a value stands: event names, which every tokenizer reads as
+ * an event (`set input to "a"` dropped from English's own parse), structure
+ * words (`when`, which every language wrote as its keyword), and words of the
+ * value lexicon (`index`, which bn and four others wrote natively) — P49, P28.
+ * Not a name the window already holds (`focus`, `length`), nor `then`: the
+ * fixture sets each name there, and a `then` on the window makes upstream
+ * take it for a promise. Not yet `if` or `end`, which open and close a block
+ * in every language's reader (OPEN_ITEMS P53: 93 and 505 failing pairs).
+ */
+export const KEYWORD_NAMES: readonly string[] = [
+  'click',
+  'input',
+  'change',
+  'keyup',
+  'submit',
+  'load',
+  'drop',
+  'when',
+  'index',
+  'value',
+];
+
 /**
  * Variables spelled like a structure word of a language the matrix translates
  * into: every one- or two-letter name semantic's `nameCollision` finds
@@ -580,14 +604,15 @@ export function collidingNames(): readonly CollidingName[] {
     const tokens = tokenize(word, 'en').tokens;
     return tokens.length === 1 && tokens[0]?.kind !== 'identifier';
   };
-  collidingNamesMemo = candidates
-    .filter(word => !reserved.has(word) && !englishKeyword(word))
+  collidingNamesMemo = [...new Set([...candidates, ...KEYWORD_NAMES])]
+    .filter(word => !reserved.has(word) && (KEYWORD_NAMES.includes(word) || !englishKeyword(word)))
     .flatMap(name => {
       const readings = FOREIGN_LANGUAGES.map(language => ({
         language,
         collision: nameCollision(name, language),
       }));
-      if (!readings.some(reading => reading.collision === 'structure')) return [];
+      const structure = readings.some(reading => reading.collision === 'structure');
+      if (!structure && !KEYWORD_NAMES.includes(name)) return [];
       const pronounIn = readings.filter(r => r.collision === 'pronoun').map(r => r.language);
       return [{ name, pronounIn }];
     });