@lokascript/framework 4.0.1 → 4.1.0

package/CHANGELOG.md

@@ -7,6 +7,152 @@ 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
@@ -1095,7 +1241,8 @@ _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/v4.0.1...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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lokascript/framework",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Generic framework for building multilingual DSLs with semantic parsing and grammar transformation",
   "type": "module",
   "main": "dist/index.cjs",
@@ -96,7 +96,7 @@
   "author": "LokaScript Contributors",
   "license": "MIT",
   "dependencies": {
-    "@lokascript/intent": "^4.0.1"
+    "@lokascript/intent": "^4.1.0"
   },
   "devDependencies": {
     "@lokascript/domains": "^3.0.1",