@hyperfixi/testing-framework 4.2.0 → 4.3.0

package/CHANGELOG.md

@@ -7,6 +7,68 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.3.0] - 2026-10-07
+
+More of what upstream reads now translates, and what does not is refused instead of lost. On the
+command-shape gate, round trips that came back silently different fell from 174 in 4.2.0 to 31,
+none of them in English; 24,386 of 27,240 now read as their source does. English-to-English refuses
+61 of the 1,135 scripts, down from 82, and each of the 61 now belongs to a named family with the
+reason it is not carried yet.
+
+### Added
+
+- **`@lokascript/semantic` reads `on every <event>` and `init immediately`.** Both lost their head
+  word, so the handler or the block was refused. `EventHandlerSemanticNode.eventModifiers.every` and
+  `FeatureSemanticNode.immediately` carry them. English writes them as upstream does; every other
+  language writes the English word first (`every al clic …`), as it already did for `on first`.
+- **`@hyperfixi/testing-framework`: two new value-matrix axes.** A `branch` position is an `if` with
+  no `then` before a command that names no target (`if 2 is in arr add .a end`). The matrix's `if`
+  cells always wrote `then` and a `put` with its target, so an SOV reader always saw where the
+  condition ended, and none of them could fail the way Turkish did (see Fixed). The 610 pairs that
+  `branch` refuses are listed in the baseline. A twelfth operand kind is a CSS length (`100px`,
+  `50%`). The matrix now has 5,396 cells.
+
+### Changed
+
+- **`@lokascript/semantic` refuses core's swap strategies that upstream has no spelling for.**
+  `translate()` gains a loss kind, `'core-only'` (`TranslationLossKind`). Upstream and the engine
+  read `swap morph of #t with it` as an exchange with a property named `morph`, so core's morph
+  strategies, `none`, and a strategy with no content are now refused in every language. Before,
+  English wrote them as they were read. Core's `swap into #t with x` and `swap over #t with x` are its
+  innerHTML and outerHTML, and they are now written as `put x into #t` and `put x into #t's
+outerHTML`. Before, English wrote `swap into of #t with x`, which runs as an exchange.
+- **`@lokascript/semantic` writes a word in the target language only where that language's reader
+  brings it back.** A property name is localized only through the reader's property table or as a
+  keyword. So `add .foo to my children` keeps `children` in Spanish (`mi children`), where it wrote
+  `mi hijos` and read back a property named `hijos`. A call's arguments are written as written
+  (`call sprayInto(me)` wrote `sprayInto(yo)`). So is every bracket group inside an expression:
+  `2 is in [true, n]` wrote `[verdadero, n]` in Spanish, a variable no reader de-localizes. And so is a
+  type name after `am a`. These spots now show English words in foreign renders where they used to
+  show words that did not come back.
+- **`@lokascript/semantic`: `innerHTML` and `outerHTML` are no longer English keywords.** A swap's
+  strategy slot still reads them, as words.
+
+### Fixed
+
+- **`@lokascript/semantic`: Turkish keeps an `if` condition whole before a command with no target.**
+  `if 2 is in arr add .a end` read back as `if 2 add .a to is in arr end`, with any operand, and so
+  did `is a Number` and `<` after a possessive. Turkish case markers may be dropped, and the marker
+  test counted a marker word anywhere in the value: `in` (also the operator), `a` (also the article),
+  `nin` (also the possessive). The marker must now be the last token of its group.
+- **`@lokascript/semantic`: a number with a CSS unit is one value.** Upstream reads `100px`,
+  `1.5rem` and `50%` as one string. Every tokenizer split them, so `set my *width to 100px` and
+  `transition height to 100px` were refused in all 24 languages. A `%` that an operand touches
+  (`5%2`) or that is spaced still reads as the operator.
+- **`@lokascript/semantic`: more English forms that were refused in every language now read.**
+  `set innerHTML of #d1 to …` and `increment innerHTML of #d1`; a single-quoted string that holds a
+  `"` (`set #t to '<div _="…">'`), which was written back in double quotes and so closed early;
+  `fetch … don't throw`; `put … at the start of` / `at the end of`, where the `end` closed the
+  handler; `remove 3 from :arr` and `remove {color} from me`; `otherwise` as `else`. In a translation
+  of an empty then-branch's `otherwise`, 13 languages wrote their own word for it inside the
+  condition and read it back there, silently.
+- **`@lokascript/semantic`: a handler's `catch` and `finally` bodies are written in upstream's
+  spelling.** `catch e prepend …` kept core's `prepend`, which the engine rejects.
+
 ## [4.2.0] - 2026-10-07
 
 A translation that would lose part of a script is now refused instead of returned short.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperfixi/testing-framework",
-  "version": "4.2.0",
+  "version": "4.3.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.2.0",
-    "@lokascript/compilation-service": "^4.2.0",
-    "@lokascript/i18n": "^4.2.0",
-    "@lokascript/semantic": "^4.2.0",
+    "@hyperfixi/patterns-reference": "^4.3.0",
+    "@lokascript/compilation-service": "^4.3.0",
+    "@lokascript/i18n": "^4.3.0",
+    "@lokascript/semantic": "^4.3.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.2.0",
-    "@lokascript/hyperscript-adapter": "^4.2.0",
+    "@hyperfixi/engine": "^4.3.0",
+    "@lokascript/hyperscript-adapter": "^4.3.0",
     "@types/diff": "^5.0.0",
     "@types/node": "^26.6.3",
     "@vitest/coverage-v8": "^5.0.0",

package/src/multilingual/command-shapes.ts

@@ -589,6 +589,115 @@ export const LOUD: readonly LoudFamily[] = [
       "a possessive with nothing after it (`halt the event's then …`), which the engine " +
       'reads as the bare reference; one upstream test source',
     matches: source => /'s(?=\s+(then|end)\b|\s*$)/.test(source),
+  }, // M1 step 3 (2026-10-07): the English refusals left after the value and
+  // command-form fixes, each family with why it is not carried.
+  {
+    name: 'scroll-by',
+    reason:
+      "scroll's relative form (`scroll #box down by 200px`) names a direction, which no " +
+      "language's dictionary has: adding them is an owner vocabulary decision (the M2 sheet)",
+    matches: (_source, _types, plain) =>
+      someNode(plain, node => node.type === 'scrollCommand' && 'by' in node),
+  },
+  {
+    name: 'beep',
+    reason:
+      "`beep!`, upstream's debugging command, has no schema: its form in each language is an " +
+      'owner vocabulary decision (the M2 sheet)',
+    matches: (_source, types) => types.has('beepCommand'),
+  },
+  {
+    name: 'halt-modes',
+    reason:
+      "halt's `default` (also a command word) and `the event's bubbling|default`: the slot " +
+      'that keeps `call` out of `halt call f()` cannot tell `default` from a command without ' +
+      'a halt-only reading (OPEN_ITEMS P56)',
+    matches: source => /\bhalt\s+(default\b|the event's\s+(bubbling|default)\b)/.test(source),
+  },
+  {
+    name: 'collection-expressions',
+    reason:
+      "upstream 0.9.93's collection expressions (`… where it matches .a`, `mapped to`) are an " +
+      "expression form semantic's reader does not have: a parser-track item (OPEN_ITEMS P57)",
+    // Not `if no <q/> in … where …`, which English reads (its foreign lanes are
+    // the value-words family).
+    matches: (source, types) => types.has('collectionExpression') && !/\bif\s+no\s+</.test(source),
+  },
+  {
+    name: 'pseudo-class-query',
+    reason:
+      'a query of a pseudo-class (`<:checked/>`): the tokenizers read `:checked` as a local ' +
+      'variable; a tokenizer item, rare in pages',
+    matches: source => /<:[\w-]+\/>/.test(source),
+  },
+  {
+    name: 'closest-forms',
+    reason:
+      "`closest @attr` (an ancestor's attribute) and `closest parent <q/>`: the forms of " +
+      '`closest` besides a query, rare in pages',
+    matches: (_source, _types, plain) =>
+      someNode(
+        plain,
+        node =>
+          node.type === 'closestExpr' &&
+          // Not `closest @foo to #d1`, which English reads (value-words).
+          (node.parentSearch === true ||
+            (String(node.css ?? '').startsWith('[') &&
+              (node.to as { type?: unknown } | undefined)?.type === 'implicitMeTarget'))
+      ),
+  },
+  {
+    name: 'possessive-after-query',
+    reason:
+      "a possessive after a positional query (`the next <div/>'s textContent`), rare in pages; " +
+      'the `of` form (`the textContent of the next <div/>`) is carried',
+    matches: (source, types) => types.has('relativePositionalExpression') && /\/>'s\b/.test(source),
+  },
+  {
+    name: 'colon-event-arguments',
+    reason: 'a colon-qualified event name with arguments (`send foo:bar(x:42)`), rare in pages',
+    matches: (source, types) => types.has('namedArgumentList') && /\w:\w+\(/.test(source),
+  },
+  {
+    name: 'call-chain-command',
+    reason: 'a call chain as a command (`bar().foo()`), rare in pages',
+    matches: (source, types) => types.has('pseudoCommand') && /\)\.\w+\(/.test(source),
+  },
+  {
+    name: 'rare-heads',
+    reason:
+      'handler heads rare in pages: a quoted event name (`on "a-b"`), a filter after ' +
+      'parameters (`on foo(bar)[bar]`), `and on`, a source on each `or` leg, a ' +
+      'parenthesized feature (`(on click …)`)',
+    matches: source =>
+      /^\s*on\s+"|^\s*on\s+[\w:.-]+\([^)]*\)\[|\bon\s+\w+\s+\d+\s+and\s+on\b|\bfrom\s+\S+\s+or\s+\w+\s+from\b|^\s*\(on\s/.test(
+        source
+      ),
+  },
+  {
+    name: 'rare-values',
+    reason:
+      'value spellings rare in pages: an escaped class name (`.group-\\[…\\]`), a comma ' +
+      'list in a query (`<#d1, #d2/>`), an attribute after a bare or bracketed reference ' +
+      '(`it @a`, `my [@a]`), a dotted path before `of`, a unit after parentheses ' +
+      '(`(w)px`), `set {…} on <obj>`',
+    matches: source =>
+      /\\\[|<[^<>]*,[^<>]*\/>|\b(my|its|your)\s+\[@|\bset\s+(it|me|you)\s+@|\b[a-z]\w*\.[a-z]\w*\s+of\b|\)(px|em|rem|%)|\bset\s+\{[^}]*\}\s+on\b/i.test(
+        source
+      ),
+  },
+  {
+    name: 'rare-commands',
+    reason:
+      'commands rare in pages: `measure` of a property list, `pick characters 0 to 3 from …`, ' +
+      'an `if` whose body is empty (`if false end`), a behavior holding a bare command, two ' +
+      'behaviors with no `end` between',
+    matches: (source, types, plain) =>
+      (types.has('measureCommand') && /\bmeasure\s+\w+\s*,/.test(source)) ||
+      someNode(plain, node => node.type === 'pickCommand' && node.variant === 'range') ||
+      /\bif\s+\S+\s+end\b/.test(source) ||
+      (types.has('behaviorFeature') && types.has('setFeature')) ||
+      (source.match(/\bbehavior\b/g)?.length ?? 0) > 1,
   },
 ];
 
@@ -606,28 +715,6 @@ export interface SilentFamily {
 }
 
 export const SILENT_FAMILIES: readonly SilentFamily[] = [
-  {
-    name: 'localized-call-arguments',
-    reason:
-      "a call's arguments are written in the target language (`sprayInto(أنا)`, " +
-      '`writeText(قيمة لـ #input)`) and read back raw, so English holds the foreign words',
-    ids: ['2d6fa6cf27', '2218bab0ca'],
-  },
-  {
-    name: 'localized-dom-names',
-    reason:
-      'a DOM property or type name is translated as a word (`my children` → de `my kinder`, ' +
-      '`my style[…]` → `my stil […]`, `a Element` → ar `a عنصر`) and not read back',
-    ids: [
-      '76bf595d21',
-      'a1ca7a74a0',
-      'e172bd73af',
-      'ddb498424a',
-      'dc9ce23e31',
-      'bf3ceac332',
-      '8ecf869842',
-    ],
-  },
   {
     name: 'value-words',
     reason:
@@ -645,13 +732,6 @@ export const SILENT_FAMILIES: readonly SilentFamily[] = [
       '54a65f4602',
     ],
   },
-  {
-    name: 'else-word',
-    reason:
-      "an empty then-branch's `otherwise` (de `andernfalls`, …) is not read as `else` and " +
-      'stays a word in the condition',
-    ids: ['e60afa928a'],
-  },
   {
     name: 'it-locative',
     reason: 'it `in me` (a query scope) reads back as `on me`',

package/src/multilingual/value-matrix.branch-phrases.test.ts

@@ -0,0 +1,13 @@
+/**
+ * Value matrix gate — the `branch` position's operator-phrase cells (`is equal
+ * to`, `includes`, `is an Element`, …). See value-matrix.ts for the matrix
+ * and value-matrix-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 { describeValueMatrixShard } from './value-matrix-gate';
+
+describeValueMatrixShard('branch', 'phrases');

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

@@ -0,0 +1,13 @@
+/**
+ * Value matrix gate — the `branch` cells. See value-matrix.ts for the matrix and
+ * value-matrix-gate.ts for the assertions; one position per file so the
+ * shards run in parallel.
+ *
+ * @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 { describeValueMatrixShard } from './value-matrix-gate';
+
+describeValueMatrixShard('branch');

package/src/multilingual/value-matrix.ts

@@ -9,16 +9,17 @@
  *
  * This does. A CELL is one value expression in one position:
  *
- *   - OPERANDS: eleven kinds (literal, variable, selector, possessive, `of`,
+ *   - OPERANDS: twelve kinds (literal, variable, selector, possessive, `of`,
  *     dotted, call, array, parens, a reference's property: `event's type`,
- *     `the id of target`, and a sigil variable: `$n`), each with instances
- *     of the value types it produces;
+ *     `the id of target`, a sigil variable: `$n`, and a CSS length: `100px`),
+ *     each with instances of the value types it produces;
  *   - OPERATORS: arithmetic, comparison, equality, logic, membership, and the
  *     prefix and postfix forms (`not`, `-`, `no`, `is empty`, `is null`,
  *     `exists`, `as`), and core's operator PHRASES (`is greater than or equal
  *     to`, `does not include`, `is an Element`, …);
- *   - POSITIONS: a `put` value, a `set` value, an `if` condition, a `repeat
- *     while` condition, a loop's count (`repeat … times`), an `increment …
+ *   - POSITIONS: a `put` value, a `set` value, an `if` condition, an `if`
+ *     condition with no `then` before a command that names no target
+ *     (`branch`), a `repeat while` condition, a loop's count (`repeat … times`), an `increment …
  *     by` amount, a `set` value in the second command of a chain (`chain`),
  *     what a `get` reads (`get`), and two written targets: what a `set`
  *     writes (`assign`) and what an `increment` counts (`count`).
@@ -112,15 +113,27 @@ export type OperandKind =
   | 'array'
   | 'parens'
   | 'reference'
-  | 'sigil';
+  | 'sigil'
+  | 'length';
 
 export type Position =
-  'put' | 'set' | 'if' | 'while' | 'times' | 'increment' | 'chain' | 'get' | 'assign' | 'count';
+  | 'put'
+  | 'set'
+  | 'if'
+  | 'branch'
+  | 'while'
+  | 'times'
+  | 'increment'
+  | 'chain'
+  | 'get'
+  | 'assign'
+  | 'count';
 
 export const POSITIONS: readonly Position[] = [
   'put',
   'set',
   'if',
+  'branch',
   'while',
   'times',
   'increment',
@@ -164,7 +177,7 @@ export interface MatrixCell {
  */
 export const FIXTURE =
   '<div id="out">∅</div>' +
-  '<p id="a" class="x" title="t1">6</p>' +
+  '<p id="a" class="x" title="t1" aria-pressed="true">6</p>' +
   '<div id="w"><p class="w">w</p><p class="w">v</p></div>' +
   '<button id="b">b</button>';
 
@@ -197,12 +210,16 @@ export const OPERANDS: readonly Operand[] = [
   { kind: 'possessive', type: 'num', text: "obj's v" },
   { kind: 'possessive', type: 'num', text: "arr's length" },
   { kind: 'possessive', type: 'num', text: "#a's textContent's length" },
+  // A property name a lexicon translates and no reader brings back: es wrote
+  // `hijos`, which read back as a property named `hijos`.
+  { kind: 'possessive', type: 'num', text: "#w's children's length" },
   { kind: 'of', type: 'nstr', text: 'textContent of #a' },
   { kind: 'of', type: 'nstr', text: 'the textContent of #a' },
   { kind: 'of', type: 'num', text: 'v of obj' },
   { kind: 'of', type: 'num', text: 'length of arr' },
   { kind: 'of', type: 'str', text: '@title of #a' },
   { kind: 'of', type: 'num', text: 'v of w of obj' },
+  { kind: 'of', type: 'num', text: 'the length of the children of #w' },
   { kind: 'of', type: 'arr', text: 'textContent of .w' },
   { kind: 'dotted', type: 'nstr', text: '#a.textContent' },
   { kind: 'dotted', type: 'str', text: 'me.id' },
@@ -213,8 +230,15 @@ export const OPERANDS: readonly Operand[] = [
   { kind: 'call', type: 'nstr', text: 'String(n)' },
   { kind: 'call', type: 'str', text: 's.toUpperCase()' },
   { kind: 'call', type: 'bool', text: 'Array.isArray(arr)' },
+  // A word a lexicon translates, inside a call's arguments, which every reader
+  // takes as written: es `Math.max(n, verdadero)`.
+  { kind: 'call', type: 'num', text: 'Math.max(n, true)' },
   { kind: 'array', type: 'arr', text: '[1, 2]' },
   { kind: 'array', type: 'arr', text: '[n, 2]' },
+  // A word some language's lexicon translates, inside an array in a larger
+  // expression: every reader takes a bracket group whole, so a renderer that
+  // localized `true` there (es `2 is in [verdadero, n]`) lost it in all 23.
+  { kind: 'array', type: 'arr', text: '[true, n]' },
   { kind: 'parens', type: 'num', text: '(n + 1)' },
   { kind: 'parens', type: 'str', text: '(s + "c")' },
   { kind: 'parens', type: 'bool', text: '(n > 1)' },
@@ -235,6 +259,10 @@ export const OPERANDS: readonly Operand[] = [
   // a variable, but no cell had one: semantic's English dropped a whole loop
   // counted by one (`repeat $n times`), and every translation with it.
   { kind: 'sigil', type: 'num', text: '$n' },
+  // A number with a CSS unit is one string upstream (`100px`): every reader
+  // split it, so `set my *width to 100px` was refused in all 24 languages.
+  { kind: 'length', type: 'str', text: '100px' },
+  { kind: 'length', type: 'str', text: '50%' },
 ];
 
 /** An operator slot, and the value types that fill it. */
@@ -330,7 +358,16 @@ export const BINARY_OPERATORS: readonly BinaryOperator[] = [
     representative: true,
     signatures: [sig('num', 'arr', '2', '[1, 2, 6]', 'bool')],
   },
-  { op: 'matches', representative: true, signatures: [sig('one', 'none', '#a', '.x', 'bool')] },
+  {
+    op: 'matches',
+    representative: true,
+    // An attribute selector whose value a lexicon translates: es wrote
+    // `<[aria-pressed=verdadero]/>`, another selector, in all 23 languages.
+    signatures: [
+      sig('one', 'none', '#a', '.x', 'bool'),
+      sig('one', 'none', '#a', '<[aria-pressed=true]/>', 'bool'),
+    ],
+  },
   // Operator PHRASES (the after-85 handoff, part 2): the words each language
   // renders for them are read back by the join and the sense table, which no
   // single-word operator exercises. One of each class is representative, so the
@@ -623,6 +660,7 @@ const TEMPLATES: Record<Position, (expression: string) => string> = {
   put: e => `on click put ${e} into #out`,
   set: e => `on click set x to ${e} then put x into #out`,
   if: e => `on click if ${e} then put "Y" into #out else put "N" into #out end`,
+  branch: e => `on click if ${e} add .y else add .n end then put my className into #out`,
   while: e => `on click set i to 0 then repeat while i < ${e} increment i end then put i into #out`,
   times: e => `on click set i to 0 then repeat ${e} times increment i end then put i into #out`,
   increment: e => `on click set i to 1 then increment i by ${e} then put i into #out`,
@@ -649,10 +687,18 @@ const TEMPLATES: Record<Position, (expression: string) => string> = {
  * `it`, but its role took no literal, so English dropped `get "hello"`, `get
  * 3` and `get true` whole (and every translation with them) while `get n` and
  * `get #a's textContent` read.
+ *
+ * A `branch` condition is every `if` condition but the names (none failed
+ * there that `if` did not). The `if` cells write `then` and a `put` with its
+ * target, so a reader always saw where the condition ended. Without `then`, an
+ * SOV language writes the branch's first role right after the condition, and
+ * its reader has to find the seam: tr read `if 2 is in arr add .a end` as
+ * `if 2 add .a to is in arr end` (its destination marker is optional, and `in`
+ * is also one), with every operand, and the `if` cells all passed.
  */
 function positionsFor(type: ValueType, bare: boolean, group: MatrixCell['group']): Position[] {
   const out: Position[] = ['put', 'set'];
-  if (type === 'bool' || bare) out.push('if');
+  if (type === 'bool' || bare) out.push('if', 'branch');
   if (type === 'num' || type === 'nstr') out.push('while', 'times', 'increment');
   if (group !== 'operand-operator') out.push('chain', 'get');
   return out;