@hyperfixi/testing-framework 4.4.0 → 4.6.0

package/CHANGELOG.md

@@ -7,6 +7,196 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [4.6.0] - 2026-10-15
+
+### Added
+
+- **`@lokascript/semantic`: `ask` and `answer`** in every language's own word (es `preguntar` /
+  `responder`, ja `尋ねる` / `答える`, de `frage` / `antworte`): upstream's two dialog commands
+  (`ask "Name?"` prompts; `answer "Save?" with "Yes" or "No"` confirms, the choices after the language's
+  `with`). Both were refused in every language. Listed for native review in
+  `packages/semantic/NATIVE_REVIEW_NEEDED.md`.
+- **`@lokascript/semantic`: `scroll … by` with a direction** in every language's own words
+  (`scroll #box down by 200px`: es `desplazamiento #box abajo por 200px`, ja `#boxを 下 200px スクロール`,
+  ru `прокрутить #box вниз 200px`). Upstream's relative scroll was refused in every language: no
+  direction had a word, and scroll's schema modeled `scroll to <el>` alone. Listed for native review in
+  `packages/semantic/NATIVE_REVIEW_NEEDED.md`.
+
+### Changed
+
+- **`@lokascript/framework`: a domain DSL's parse refuses input it did not read.**
+  `createMultilingualDSL`'s `parse` (and so `compile`, `validate`, `translate`) tries every pattern and
+  takes the best match that reads the WHOLE input: highest priority, then confidence. When the only
+  matches leave input unread, it throws `UnreadInputError` (exported; `code: 'unread-input'`, with the
+  longest match's `reading` and the `unread` text). It used to return the first match however much it
+  read, so a trailing word was dropped without a word: the domain gate (lokascript-domains) found
+  1,744 of 1,744 renders accepted with an unknown word after them, and `ask what is 2+2` asked the
+  model "what". Against the gate (domains 4.0.0, measured unpublished with `gate:upstream`): 1,527
+  cases better, 62 worse, every one `pass → refused` (a value such as `click`'s that the generator
+  ignored, now refused as unread rather than dropped); no case became silent, and no accepted parse
+  changed its reading. A multi-word llm question is quoted: `ask "what is 2+2"`.
+- **`@lokascript/framework`: a domain DSL's `translate` refuses a rendering that does not read
+  back.** It reads its output in the target language and requires the source command: the same
+  action and role values, or the same compiled code. Otherwise it throws `TranslationReadBackError`
+  (exported; the text under `partial`, what it reads as under `reading`), unless `{ lossy: 'allow' }`,
+  as semantic's `translate`. `DomainRegistry`'s tools (the MCP `parse_` / `compile_` / `validate_` /
+  `translate_<domain>` tools) report refusals as `ok: false` with an `UNREAD_INPUT` or
+  `TRANSLATION_DOES_NOT_READ_BACK` diagnostic instead of a generic tool error, and `translate_<domain>`
+  reads its own rendering back the same way. Translating every domain gate command from English: 46
+  renders that used to be returned are now refused (45 do not parse in the target language).
+- **`@lokascript/semantic`: the parser is split into modules.** `semantic-parser.ts` went from 9,680
+  lines to 751, across 22 modules under `parser/`, and each question about an end word (does it close a
+  block, does it stop a clause) has one reader. Each step was checked against 27,194 parses; the steps
+  that change a reading are listed under Fixed. `SemanticParseError` keeps its import path.
+
+### Fixed
+
+- **`@lokascript/semantic`: a handler's count** (`on click 1 …`, the first click only; `on click 2 …`)
+  is read in every language. The renders already wrote it (es `al clic 1 ocultar`), but every reader
+  outside English dropped it, so the translation was refused in all 23 languages. Bengali, Italian and
+  Thai also read every clause between a handler's event and its body (`on click elsewhere`,
+  `on mutation of attributes`, `on foo queue first`), which their head pattern skipped. In the command-shape
+  gate, 375 lanes that were refused now pass.
+- **`@lokascript/semantic`: a query of a pseudo-class alone** (`<:checked/>`, `<:not(.done)/>`) reads
+  as a query in every language, English too. Every tokenizer read `<` and then a local variable
+  `:checked`, so a translation was refused. In the command-shape gate, 161 lanes that were refused now
+  pass.
+- **`@lokascript/semantic`: value spellings from upstream's own tests** read in every language,
+  English too: an escaped class name (`.group-\[:nth-of-type\(3\)_\&\]:block`), a query of several
+  selectors (`<#d1, #d2/>`), a unit after parentheses (`(startWidth)px`), `[@data-foo]` and an
+  attribute after a pronoun (`set it @disabled to true`, written `its @disabled`), a dotted property
+  before `of` (`set parentNode.innerHTML of #d1 to "foo"`), and `set {bar: 2, baz: 3} on obj`. Each was
+  refused. `get` no longer has a destination slot, which no reader used and which took Italian's `in`:
+  `get #p1 in me` read back as `get #p1 on me` in Italian, and `get result as JSONString` was refused
+  in Quechua. In the command-shape gate, 202 lanes are better, 3 of them silent before.
+- **`@lokascript/semantic`: upstream's collection expressions** read in English and translate:
+  `set :items to <span/> in #box where it matches .a`,
+  `put matches mapped to its textContent into #out`, `repeat for x in :items where x.val > 10 …`. They were refused in every language, English
+  too, or kept as an English clause after the command. A translation writes the language's own `where`,
+  as it already did in a condition (es `donde`, de `wo`), and keeps `mapped to` in English until native
+  review. Also read now: an element-scoped variable (`:items`) inside a longer value, the article in
+  `in the closest <table/>` and `checked of the :boxes`, and zh/tl's `no` before a sigil variable. Quechua and
+  Vietnamese read their own `where` back (it read as `target`, or split at its `_`), which also clears a
+  silent pair in each. In the command-shape gate, 154 lanes are better, 2 of them silent before.
+- **`@lokascript/semantic`: a query's scope inside a phrase** reads in English and translates:
+  `put the length of <:checked/> in #box into me` (the value ended at the query and `in` was taken as
+  put's marker), `bind $n to the length of <:checked/> in the next <tbody/> …` (a positional scope),
+  `put <span/> in #box where it matches .a into me` (English came back silently as `… into #box …`), and
+  `put the length of <p/> into #out` and `put 'x' into the next <div/>'s textContent`, which the lossy
+  check refused because it read the `'s` after `<p/>` as a quote. In the command-shape gate, 63 lanes are
+  better, 1 of them silent before.
+- **`@lokascript/semantic`: no translation reads back as other English without saying so.** The
+  command-shape gate's last five silent pairs read back as their source: pl's `closest .bar to .foo`
+  (pl's own `to` is "it"), `closest @foo` in pl and sw, a Quechua chain of `'s` (`$data's inner's val`,
+  read as a string), and Indonesian's `saya punya @data-x`. English `set closest @foo to "doh"` and
+  `put closest @foo into me`, refused in all 24 languages, read now too.
+- **`@lokascript/semantic`: commands that semantic already models, refused in some languages,** read
+  and translate. In the command-shape gate, 168 lanes that were refused now pass; with the rows above,
+  the refused lanes of shapes semantic models went from 911 to 86, and the gate reads 26,531 pass,
+  709 refused and 0 silent. The commands:
+  - `fetch $u as JSON`, with a `$` or `:` variable as the URL (23 languages);
+  - `toggle my *display`, `*opacity` and `*visibility` (ar, de, fr, he, ja, tr);
+  - a `js(…) … end` block after `then` behind a handler head (bn, es, it, ko, pl, ru, th, tl, uk);
+  - a snake_case name (`call global_function()`), which 11 tokenizers split at its `_`;
+  - a custom event after a handler head's `or` (`on click or foo`: bn, it, ja, ko, th, tr, zh). English
+    no longer drops the second event of `on foo or bar`;
+  - `put … at end of` in Vietnamese, and in bn, hi, ja, qu and tr after a bare name
+    (`put response at end of #results`);
+  - a `set` target with no marker after it, in it, pl, ru and uk (`set .divs.innerHTML to "foo"`,
+    `#d1.parentNode`, `bar["count"]`), and `on keydown[key=="Enter"]` in ar, de, fr and he;
+  - `fetch … as Object` and `as Number` behind a bn, hi or ko handler head;
+  - a top-level `for item in items …`, which bn, hi, ko and sw read as a handler on `item`;
+  - a loop's bottom test (`repeat … until x is 3 end`) in de, fr and ko;
+  - a Korean second handler on a parameterized event (`on exception(error)`), and Polish
+    `then throw` after `do` (Polish for `into`);
+  - bn, th and vi's own word for `checked`.
+- **`@lokascript/semantic`: `at end of` inside a behavior or a def** reads in every language:
+  `behavior B on click put "x" at end of me end` was refused, English to English too, because the
+  `end` of `at end of` closed the block. A variable spelled like an end word in such a body reads too
+  (es `fin`).
+- **`@lokascript/semantic`: two copied type lists that had lost `property-path`.** Chinese reads
+  `put the textContent of last <.picked/> in #list`, which it refused, and ja, ko and zh write the count
+  of `repeat the textContent of #a times` in their own words (`#aのtextContent`), not English.
+- **`@lokascript/semantic`: Quechua's `repeat until event … from …`** writes Quechua
+  (`kama ruway pointerup ta kutipay #box manta …`), not a leftover of the retired i18n transformer with
+  English `until event` and `repeat` in it.
+- **Test runs no longer fill the temp directory**: `scripts/vitest-run.sh` gives each run its own
+  `TMPDIR` and removes it. Vitest 5.0.2 leaves a copy of every transformed module in `$TMPDIR` per run.
+
+### Removed
+
+- **`@hyperfixi/mcp-server`: the jsx domain's four tools** (`parse_jsx`, `compile_jsx`, `validate_jsx`,
+  `translate_jsx`), and `jsx` as a `domain` for `lse_validate_and_feedback`, `generate_training_data`
+  and the `lse_generate` prompt. The server now depends on `@lokascript/domains` ^4.0.0, which retired
+  jsx with six other preview domains (`docs-internal/DOMAINS_RETHINK.md`, D1). 8 domains remain (sql,
+  bdd, behaviorspec, llm, flow, voice, todo, learn): 32 domain tools, 102 tools defined, 97 listed by
+  default.
+
+## [4.5.0] - 2026-10-11
+
+Pronouns, suffixes and handler heads read as their language. In 4.4.0 every translation wrote `me` and
+`it` in the nominative beside a marker (es `a yo`, de `zu ich`, tr `ben e`, ar `إلى أنا`), wrote every
+case particle as a word of its own (ko `#out 에`, ja `"x" を`), and wrote a Japanese, Bengali or Turkish
+handler head with two markers (`クリック を で`, `ক্লিক তে`, `tıklama i üzerinde`). Each of these is now
+the language's own form, and every reader still takes the old one. The forms are listed for native
+review in `packages/semantic/NATIVE_REVIEW_NEEDED.md`; none has been reviewed yet.
+
+### Added
+
+- **`@lokascript/testing-framework`: the English-leak gate counts pronoun case and marker spacing.**
+  `case:it` and an unmarked object pronoun (`case:me-object`, `case:it-object`) beside `case:me`; and
+  `spacing:<marker>`, a particle ko, ja, bn or tr attaches to its noun written as a word of its own.
+  Both shrink-only, both halves (corpus and command shapes), with per-language exit targets in
+  `LEAK_TARGETS`.
+- **`@lokascript/semantic`: `toggle … between`** in every language's own words (ja `の間で`, hi `के बीच`,
+  he `בין`), with the style form's element written in the language.
+- **`docs-internal/multilingual/FUSED_FORMS.md`**: the design for pronouns fused with their markers and
+  suffixes attached to words, with the owner's four questions and their answers.
+
+### Changed
+
+- **`@lokascript/semantic` writes a pronoun in the case its marker takes.** Free forms: es `en mí`,
+  pt `a mim`, it `a me`, tl `sa akin`, pl `do mnie`, ru `ко мне` / `во мне`, uk `до мене`, de `zu mir`
+  / `in mich` (direction) / `auf mir` (location), hi `मुझ में`; `it` after a marker (ru `к этому`, pl
+  `do tego`, de `dazu` / `darin` / `darauf`, fr `à lui`, hi `इस में`); `me` as a verb's object (de
+  `zeige mich`, ru `покажи меня`). Fused forms: tr `bana` / `beni` / `benden`, `ona` / `onu`; ar `إليّ` / `فيه`;
+  he `אליי` / `ממני`; bn `আমাকে` / `আমাতে`; hi `मुझे`; tl `dito`; pt `nele`. Object clitics on the verb:
+  es `mostrarme`, it `metterlo`, pt `colocá-lo`, ar `ضعه`; fr writes the object pronoun before the
+  infinitive (`le mettre`, `l'afficher`, `me cacher`). Every reader takes the nominative and the English
+  forms as before.
+- **`@lokascript/semantic` writes a case particle onto its word** in ko (`"x"을 #out에 넣다`, `나를`,
+  each particle in the form the syllable takes), ja (`#outに`, `.aを`) and bn (`#outএ`, `.xকে`), and tr
+  fuses a suffix with its own reference words (`sonucu`, `hedefe`, `belgeye`) while code keeps its
+  suffix apart (`#out e`) until a reviewer picks a code word's harmony. tr also reads a suffix on code
+  after an apostrophe (`#out'a`, `.active'i`).
+- **`@lokascript/semantic`: a custom event in a wait takes the language's `event` word** (`esperar evento foo`,
+  ja `イベント foo 待つ`), as `repeat until event X` already does; a known DOM event keeps `esperar transitionend`.
+  `wait for <custom event>` was refused in every language. A possessive whose property is a reference word
+  (`its.detail`) now reads back as that property, not the language's word for it.
+- **`@lokascript/semantic`: ms and pl read their lexicon's `undefined` word** (`tidak_ditakrifkan`, `niezdefiniowane`),
+  which read back as a variable name.
+- **`@lokascript/testing-framework`: the hand-written-input gate** (`hand-written-input.test.ts`): twenty tasks a
+  native speaker writes from English, run as written on the engine against upstream; committed with no inputs.
+- **`@lokascript/semantic` writes a handler head as one word**: ja `クリックで` (was `クリック を で`),
+  bn `ক্লিকে` (the locative in the form the word takes: `জমাতে` after a vowel; was `ক্লিক তে`),
+  tr `tıklamada` (the locative in the form harmony gives: `göndermede`, `değişiklikte`; code keeps it apart, `keyup da`; was `tıklama i üzerinde`). The readers keep taking the two-marker heads.
+- **`@lokascript/semantic` writes a query's scope before the query** in bn, hi, tr, ja and ko (tr
+  `bendeki <p/>`, hi `मुझ में स्थित <p/>`, ja `自分 の中の <p/>`), where it wrote English's order.
+- **`@lokascript/semantic`: es and pt write the `focus` and `blur` commands as verbs** (`enfocarme`,
+  `focar-me`); the nouns were the events' and still read.
+- **`@lokascript/semantic`: ja's head pattern outranks its fused handler patterns**, so a ja handler's
+  body always takes the clause walk: a `js … end` block after `then` and `fetch … as T` round-trip
+  where the fused path dropped them. The 2026-08 transformer's verb-first `繰り返し イベント X を まで`
+  body no longer reads in ja (the render since 2026-08-28 does).
+
+- **`@lokascript/htmx-adapter`: the tr vocab gains `hx-da` as an alias of `hx-on`;** `hx-üzerinde` stays the name
+  (the profile's `on` word moved to the locative; a suffix is the wrong register for an attribute name).
+
+### Fixed
+
+- **`publish.yml`: a repair run skips a version npm is still processing** (`E409 previously staged`)
+  instead of failing the whole run.
+
 ## [4.4.0] - 2026-10-10
 
 Translations now read as their language. In 4.3.0, 19% of the corpus's translations and 24% of the
@@ -23,8 +213,8 @@ language has a word for. The words are the owner's vocabulary sheet
   counts, per render, the English grammar words (the tokens the engine's own parser matched in the
   source), English event names the language's lexicon has a word for, and a nominative `me` beside a
   marker in the 13 languages where that case is wrong. Two shrink-only baselines (the corpus, in
-  `test:canonical`, and the command-shape cases, in their shards); `tools/regen-english-leaks-baseline.ts
-  --report` prints each language against M2's targets. An English alternative a profile keeps for
+  `test:canonical`, and the command-shape cases, in their shards);
+  `tools/regen-english-leaks-baseline.ts --report` prints each language against M2's targets. An English alternative a profile keeps for
   code-switched input, beside a primary that is the language's own, counts as English.
 - **`@lokascript/semantic`: `transition … from … to`** reads and writes in every language (a `source`
   role), and the bare command reads in English. The schema's `destination` role is gone: upstream has
@@ -41,8 +231,8 @@ language has a word for. The words are the owner's vocabulary sheet
   back in English as upstream's first person), `does not match`, `fetch … do not throw`, `on first`,
   `go back`, `from elsewhere`, a loop's `index`, `start view transition`, a query's `in`, a conversion's
   `as` (the type name stays English), `the X of Y` inside an expression (es `valor de #price`, ja
-  `#priceの値`), `catch` and `finally`, `element x`, and `def` (as the noun "function", es `función
-  greet(name)`). bn, th and vi have their own `document` and `window`; he has its own words for all of
+  `#priceの値`), `catch` and `finally`, `element x`, and `def` (as the noun "function", es
+  `función greet(name)`). bn, th and vi have their own `document` and `window`; he has its own words for all of
   these and for `matches`, `exists`, `or`, `not`, `first`, `next`, `previous`, `closest`, `empty`, `is`,
   `document` and `window`; and the 15 languages that wrote English `forever` have their own (es
   `repetir siempre`, de `endlos`, ja `ずっと`). Every reader still takes the English words. Where a word
@@ -1546,7 +1736,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/v4.4.0...HEAD
+[Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v4.6.0...HEAD
+[4.6.0]: https://github.com/codetalcott/hyperfixi/compare/v4.5.0...v4.6.0
+[4.5.0]: https://github.com/codetalcott/hyperfixi/compare/v4.4.0...v4.5.0
 [4.4.0]: https://github.com/codetalcott/hyperfixi/compare/v4.3.0...v4.4.0
 [4.3.0]: https://github.com/codetalcott/hyperfixi/compare/v4.2.0...v4.3.0
 [4.2.0]: https://github.com/codetalcott/hyperfixi/compare/v4.1.0...v4.2.0

package/package.json

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

package/src/multilingual/README.md

@@ -297,14 +297,17 @@ parse lost the value, and every translation is rendered from it. Fix that first.
 ## English left in a translation
 
 Every gate above asks whether a translation means what the source means; none asks
-whether it reads as the language. `english-leaks.ts` counts, in each render, three kinds
+whether it reads as the language. `english-leaks.ts` counts, in each render, four kinds
 of finding:
 
-| Finding        | What it is                                                                                |
-| -------------- | ----------------------------------------------------------------------------------------- |
-| `<word>`       | an English word the engine reads as grammar in the source, written in English             |
-| `event:<name>` | an English event name where the language's lexicon has a word and the renderer may use it |
-| `case:me`      | the nominative `me` beside a role marker, in the 13 languages where that form is wrong    |
+| Finding                             | What it is                                                                                    |
+| ----------------------------------- | --------------------------------------------------------------------------------------------- |
+| `<word>`                            | an English word the engine reads as grammar in the source, written in English                 |
+| `event:<name>`                      | an English event name where the language's lexicon has a word and the renderer may use it     |
+| `case:me`                           | the nominative `me` beside a role marker, in the 13 languages where that form is wrong        |
+| `case:it`                           | the nominative `it` beside a role marker that wants another form (`CASE_RULES`)               |
+| `case:me-object` / `case:it-object` | the nominative pronoun as a command's unmarked object, where that form is wrong               |
+| `spacing:<marker>`                  | a marker ko, ja, bn or tr attaches to its noun, written apart (`#out 에`; `ATTACHED_MARKERS`) |
 
 "Grammar" is derived per source: the tokens the engine's own parser matched as words, plus
 the references in its parse. A word the language spells the same (es `a`, de `in`) and a

package/src/multilingual/command-shapes.ts

@@ -573,13 +573,6 @@ function someNode(plain: unknown, test: (node: PlainNode) => boolean): boolean {
 }
 
 export const LOUD: readonly LoudFamily[] = [
-  {
-    name: 'ask-answer',
-    reason:
-      'semantic has no schema and no dictionary word for `ask` / `answer`; adding them is an ' +
-      'owner vocabulary decision (the M2 sheet)',
-    matches: (_source, types) => types.has('askCommand') || types.has('answerCommand'),
-  },
   {
     name: 'templated-selector',
     reason:
@@ -600,14 +593,6 @@ export const LOUD: readonly LoudFamily[] = [
     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:
@@ -623,44 +608,13 @@ export const LOUD: readonly LoudFamily[] = [
       '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',
+    // `closest @attr` (an ancestor's attribute) left this family when the positional
+    // run took an attribute query (2026-10-13).
+    reason: '`closest parent <q/>`: the form of `closest` that starts at the parent, 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),
+      someNode(plain, node => node.type === 'closestExpr' && node.parentSearch === true),
   },
   {
     name: 'colon-event-arguments',
@@ -683,18 +637,6 @@ export const LOUD: readonly LoudFamily[] = [
         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:
@@ -723,35 +665,9 @@ export interface SilentFamily {
   ids: readonly string[];
 }
 
-export const SILENT_FAMILIES: readonly SilentFamily[] = [
-  {
-    name: 'value-words',
-    reason:
-      "a language's word inside a value reads back as another English word: pl `to` → " +
-      '`it`, qu `where` → `target`, ms/pl `undefined`',
-    ids: [
-      'a30e7d6174',
-      '69537d01ae',
-      'd74a86f3a0',
-      'da24c9d768',
-      'b948ed872b',
-      'a4c56acf1e',
-      '54a65f4602',
-    ],
-  },
-  {
-    name: 'it-locative',
-    reason: 'it `in me` (a query scope) reads back as `on me`',
-    ids: ['2159462e64', '0ff2f70080', 'd7b35fefe6'],
-  },
-  {
-    name: 'possessive-split',
-    reason:
-      "a possessive reads back split or reworded: qu `$data 's inner' s val`, id `my` → " +
-      '`me punya`',
-    ids: ['76130fbf7d', '36e2294330', 'b839394853'],
-  },
-];
+// Empty since 2026-10-13: the last two families (pl `to` after `closest`, qu and id
+// possessives) were reader fixes. A new silent pair needs a family here, with its reason.
+export const SILENT_FAMILIES: readonly SilentFamily[] = [];
 
 /** The silent family a case belongs to, if any. */
 export function silentFamilyOf(id: string): SilentFamily | undefined {

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

@@ -57,6 +57,11 @@ export interface DirectPathCase {
   event: string | null;
   /** The languages the core test ran; `[]` = English only. */
   languages: 'all23' | string[];
+  /**
+   * The source defines a behavior of this name (a hand-written task): it is
+   * defined under a fresh name and installed with no arguments.
+   */
+  behaviorName?: string;
 }
 
 const CASES_PATH = path.resolve(
@@ -234,6 +239,12 @@ export function caseFails(r: DirectPathResult): boolean {
 
 export interface DirectPathHosts {
   runCase(c: DirectPathCase): Promise<DirectPathResult>;
+  /**
+   * One translation someone WROTE (the hand-written-input gate), run as
+   * runCase runs a render: `written` as written on the engine with the
+   * adapter, against upstream on the English source.
+   */
+  runWritten(c: DirectPathCase, lang: string, written: string): Promise<PairResult>;
   /** Restore the console, the rejection listeners and EventTarget. */
   close(): Promise<void>;
 }
@@ -321,14 +332,17 @@ export async function initDirectPathHosts(): Promise<DirectPathHosts> {
     document.documentElement.removeAttribute('lang');
     try {
       let install = code;
-      if (c.id.startsWith('behavior-handlers')) {
+      const coreBehavior = c.id.startsWith('behavior-handlers');
+      if (coreBehavior || c.behaviorName) {
         // The source defines a behavior: define it (under a fresh name), then
-        // install it in English, as the core test does.
+        // install it in English, as the core test does. A hand-written task
+        // names its behavior (`Hider`) and installs it with no arguments.
         const name = `Demo${letter(behaviorSerial)}${letter(Math.floor(behaviorSerial / 26))}`;
         behaviorSerial++;
-        const definition = code.replace(/Demo[A-Z]+/g, name);
+        const pattern = coreBehavior ? /Demo[A-Z]+/g : new RegExp(`\\b${c.behaviorName}\\b`, 'g');
+        const definition = code.replace(pattern, name);
         host.evaluate(lang === 'en' ? definition : preprocess(definition, lang));
-        install = `install ${name}(h: 1)`;
+        install = coreBehavior ? `install ${name}(h: 1)` : `install ${name}()`;
         lang = 'en';
       }
       document.body.innerHTML = c.fixture;
@@ -386,15 +400,44 @@ export async function initDirectPathHosts(): Promise<DirectPathHosts> {
     }
   };
 
-  return {
-    async runCase(c) {
-      // A behavior definition is not a handler: it is checked by running it.
-      const rejected = c.id.startsWith('behavior-handlers')
+  /** Upstream on the English source: the oracle, or why there is none. */
+  type Oracle = { rejected: string | undefined; want: string };
+  const oracle = async (c: DirectPathCase): Promise<Oracle> => {
+    // A behavior definition is not a handler: it is checked by running it.
+    const rejected =
+      c.id.startsWith('behavior-handlers') || c.behaviorName
         ? undefined
         : rejects(upstream, c.source);
-      const want = rejected
-        ? `✗upstream rejects: ${rejected}`
-        : await runAll(upstream, c, c.source, 'en');
+    const want = rejected
+      ? `✗upstream rejects: ${rejected}`
+      : await runAll(upstream, c, c.source, 'en');
+    return { rejected, want };
+  };
+  /** One translation, written or rendered, on the engine against the oracle. */
+  const pairFor = async (
+    c: DirectPathCase,
+    { rejected, want }: Oracle,
+    lang: string,
+    written: string
+  ): Promise<PairResult> => {
+    let english: string;
+    try {
+      english = preprocess(written, lang);
+    } catch (e) {
+      english = `✗${(e as Error).message}`;
+    }
+    const got = await runAll(engine, c, written, lang);
+    let ref = want;
+    if (rejected && !english.startsWith('✗') && !rejects(upstream, english)) {
+      ref = await runAll(upstream, c, english, 'en');
+    }
+    const ok = got === ref && !EMPTY.test(ref) && !ref.startsWith('✗');
+    return { lang, written, english, got, ref, ok };
+  };
+
+  return {
+    async runCase(c) {
+      const o = await oracle(c);
       const eng = await runAll(engine, c, c.source, 'en');
       const languages = c.languages === 'all23' ? [...FOREIGN_LANGUAGES] : c.languages;
       const node = parseSemantic(c.source, 'en').node;
@@ -407,24 +450,15 @@ export async function initDirectPathHosts(): Promise<DirectPathHosts> {
           written = null;
         }
         if (written === null) {
-          pairs.push({ lang, written, english: '', got: '✗untranslatable', ref: want, ok: false });
+          pairs.push({ lang, written, english: '', got: '✗untranslatable', ref: o.want, ok: false });
           continue;
         }
-        let english: string;
-        try {
-          english = preprocess(written, lang);
-        } catch (e) {
-          english = `✗${(e as Error).message}`;
-        }
-        const got = await runAll(engine, c, written, lang);
-        let ref = want;
-        if (rejected && !english.startsWith('✗') && !rejects(upstream, english)) {
-          ref = await runAll(upstream, c, english, 'en');
-        }
-        const ok = got === ref && !EMPTY.test(ref) && !ref.startsWith('✗');
-        pairs.push({ lang, written, english, got, ref, ok });
+        pairs.push(await pairFor(c, o, lang, written));
       }
-      return { id: c.id, want, eng, pairs };
+      return { id: c.id, want: o.want, eng, pairs };
+    },
+    async runWritten(c, lang, written) {
+      return pairFor(c, await oracle(c), lang, written);
     },
     async close() {
       await new Promise(resolve => setTimeout(resolve, 0));