@hyperfixi/testing-framework 4.4.0 → 4.5.0

package/CHANGELOG.md

@@ -7,6 +7,71 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [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
@@ -1547,6 +1612,7 @@ _Synchronized version release. See git history for details._
 - 2FA recommended for npm organization
 
 [Unreleased]: https://github.com/codetalcott/hyperfixi/compare/v4.4.0...HEAD
+[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.5.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.5.0",
+    "@lokascript/compilation-service": "^4.5.0",
+    "@lokascript/i18n": "^4.5.0",
+    "@lokascript/semantic": "^4.5.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.5.0",
+    "@lokascript/hyperscript-adapter": "^4.5.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

@@ -728,16 +728,8 @@ 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',
-    ],
+      '`it` (its `it` word, after `closest`), qu `where` → `target`, vi `where` split at `_`',
+    ids: ['d74a86f3a0', 'da24c9d768', 'b948ed872b'],
   },
   {
     name: 'it-locative',

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));

package/src/multilingual/english-leaks.test.ts

@@ -34,6 +34,11 @@ function keys(source: string, render: string, language: string): string[] {
   return scanner.scan(render, info, language).map(findingKey).sort();
 }
 
+/** The same, of one kind (the spaced markers of tr and ja stand beside their cases). */
+function keysOf(kind: string, source: string, render: string, language: string): string[] {
+  return keys(source, render, language).filter(k => k.startsWith(`${kind}:`));
+}
+
 function findings(source: string, render: string, language: string): LeakFinding[] {
   const info = scanner.sourceInfo(source, 'program');
   if (!info) throw new Error(`the engine rejects ${source}`);
@@ -102,7 +107,7 @@ describe('english-leaks scanner', () => {
     expect(
       keys(
         'on click js(me) return new Date() end then put it into #a',
-        'al clic js (me) return new Date() fin entonces poner ello en #a',
+        'al clic js (me) return new Date() fin entonces ponerlo en #a',
         'es'
       )
     ).toEqual([]);
@@ -128,7 +133,7 @@ describe('english-leaks scanner', () => {
     expect(
       keys(
         'on click put me into #a then js(me) return 1 end',
-        'al clic poner yo en #a entonces js (me) return 1 fin',
+        'al clic ponerme en #a entonces js (me) return 1 fin',
         'es'
       )
     ).toEqual([]);
@@ -195,10 +200,117 @@ describe('english-leaks scanner', () => {
 
   it('counts a nominative `me` beside a marker, in the languages where that is wrong', () => {
     expect(keys('on click add .b to me', 'al clic agregar .b a yo', 'es')).toEqual(['case:me']);
-    expect(keys('on click add .b to me', 'tıklama da .b i ben e ekle', 'tr')).toEqual(['case:me']);
+    expect(keysOf('case', 'on click add .b to me', 'tıklama da .b i ben e ekle', 'tr')).toEqual([
+      'case:me',
+    ]);
     // fr writes the stressed form; ja's particle attaches to any noun.
     expect(keys('on click add .b to me', 'sur clic ajouter .b à moi', 'fr')).toEqual([]);
-    expect(keys('on click add .b to me', 'クリック で 自分 に .b を 追加', 'ja')).toEqual([]);
+    expect(keysOf('case', 'on click add .b to me', 'クリック で 自分 に .b を 追加', 'ja')).toEqual(
+      []
+    );
+    // The oblique forms are right.
+    expect(keys('on click add .b to me', 'al clic agregar .b a mí', 'es')).toEqual([]);
+    expect(keys('on click add .b to me', 'при клик добавить .b ко мне', 'ru')).toEqual([]);
+    // it writes `me` after a marker: the profile's own word, not English's.
+    expect(keys('on click put "x" into me', 'su clic mettere "x" in me', 'it')).toEqual([]);
+    expect(keys('on click put "x" into me', 'su clic mettere "x" in io', 'it')).toEqual([
+      'case:me',
+    ]);
+  });
+
+  it('counts a nominative `it` beside a marker, where the language has another form', () => {
+    const source = 'on click add .b to it';
+    expect(keys(source, 'при клик добавить .b к это', 'ru')).toEqual(['case:it']);
+    expect(keys(source, 'wenn klick hinzufügen .b zu es', 'de')).toEqual(['case:it']);
+    expect(keysOf('case', source, 'tıklama i üzerinde o e .b i ekle', 'tr')).toEqual(['case:it']);
+    expect(keys(source, 'при клик добавить .b к этому', 'ru')).toEqual([]);
+    // es `ello` and it `esso` are right after a marker.
+    expect(keys(source, 'al clic agregar .b a ello', 'es')).toEqual([]);
+    expect(keys(source, 'su clic aggiungere .b a esso', 'it')).toEqual([]);
+    // pt: only `em` and `de` contract with `ele` (nele, dele); `a ele` is right.
+    expect(keys('on click put "x" into it', 'ao clique colocar "x" em ele', 'pt')).toEqual([
+      'case:it',
+    ]);
+    expect(keys(source, 'ao clique adicionar .b a ele', 'pt')).toEqual([]);
+    // The ru/uk/pl demonstrative's accusative is its nominative: right after a
+    // marker that takes the accusative (a direction), wrong after one that never does.
+    const into = 'on click put "x" into it';
+    expect(keys(into, 'при клик положить "x" в это', 'ru')).toEqual([]);
+    expect(keys(into, 'gdy kliknięcie umieść "x" w to', 'pl')).toEqual([]);
+    expect(keys(source, 'gdy kliknięcie dodaj .b do to', 'pl')).toEqual(['case:it']);
+    expect(keys(source, 'при клік додати .b до це', 'uk')).toEqual(['case:it']);
+    // tl `bago ito` (before this) is right; `sa ito` is `dito`.
+    expect(keys(source, 'kapag click idagdag .b sa ito', 'tl')).toEqual(['case:it']);
+    expect(keys('on click wait 1s', 'kapag click maghintay bago ito', 'tl')).toEqual([]);
+  });
+
+  it('does not count a pronoun that opens a parenthesized expression', () => {
+    const source = 'on click set $b to (it * 2)';
+    expect(keys(source, 'wenn klick setze $b auf (es * 2)', 'de')).toEqual([]);
+    expect(keys('on click set $b to it', 'wenn klick setze $b auf es', 'de')).toEqual(['case:it']);
+  });
+
+  it("counts a nominative pronoun as a verb's unmarked object, where that is wrong", () => {
+    expect(keys('on click measure me', 'wenn klick messen ich', 'de')).toEqual(['case:me-object']);
+    expect(keys('on click show me', 'al clic mostrar yo', 'es')).toEqual(['case:me-object']);
+    expect(keys('on click hide it', 'al clic ocultar ello', 'es')).toEqual(['case:it-object']);
+    expect(keys('on click hide it', 'quand clic cacher il', 'fr')).toEqual(['case:it-object']);
+    expect(keys('on click put me into #o', 'при клик положить я в #o', 'ru')).toEqual([
+      'case:me-object',
+    ]);
+    // A verb its patterns write (de `verstecke`; the keyword is `verbergen`).
+    expect(keys('on click hide me', 'wenn klick verstecke ich', 'de')).toEqual(['case:me-object']);
+    // The right object forms, and the objects that are right in the nominative.
+    expect(keys('on click measure me', 'wenn klick messen mich', 'de')).toEqual([]);
+    expect(keys('on click hide it', 'wenn klick verstecke es', 'de')).toEqual([]);
+    expect(keys('on click hide it', 'при клик скрыть это', 'ru')).toEqual([]);
+    // fr writes the clitic before the infinitive (`m'afficher`, `me cacher`), and
+    // `me` there is its own word.
+    expect(keys('on click show me', 'quand clic afficher moi', 'fr')).toEqual(['case:me-object']);
+    expect(keys('on click show me', "quand clic m'afficher", 'fr')).toEqual([]);
+    expect(keys('on click hide me', 'quand clic me cacher', 'fr')).toEqual([]);
+    expect(keys('on click hide it', 'quand clic le cacher', 'fr')).toEqual([]);
+    // A condition is not an object: `if` is no verb.
+    expect(
+      keys('on click if it is empty hide me end', 'al clic si ello es vacío ocultar yo fin', 'es')
+    ).toEqual(['case:me-object']);
+    // A word before the pronoun that is no verb at all.
+    expect(keys('on click put it into #o', 'al clic ello en #o', 'es')).toEqual([]);
+  });
+
+  it('counts a marker its language attaches, written apart (N5)', () => {
+    const source = 'on click put "x" into #out';
+    expect(keys(source, '클릭 할 때 "x" 을 #out 에 넣다', 'ko')).toEqual([
+      'spacing:에',
+      'spacing:을',
+    ]);
+    expect(keys(source, 'クリック で "x" を #out に 置く', 'ja')).toEqual([
+      'spacing:で',
+      'spacing:に',
+      'spacing:を',
+    ]);
+    expect(keys(source, 'ক্লিক তে "x" কে #out এ রাখুন', 'bn')).toEqual([
+      'spacing:এ',
+      'spacing:কে',
+      'spacing:তে',
+    ]);
+    expect(keys(source, 'tıklama i üzerinde "x" i #out e koy', 'tr')).toEqual([
+      'spacing:e',
+      'spacing:i',
+      'spacing:i',
+    ]);
+    // Attached, nothing; a postposition that is its own word is spaced.
+    expect(keys(source, '클릭 할 때 "x"를 #out에 넣다', 'ko')).toEqual([]);
+    expect(keys(source, 'クリックで "x"を #outに 置く', 'ja')).toEqual([]);
+    expect(keys(source, 'tıklamada "x"\'i #out\'a koy', 'tr')).toEqual([]);
+    expect(
+      keys('on click hide <p/> in #list', "tıklamada #list içindeki <p/>'yi gizle", 'tr')
+    ).toEqual([]);
+    // A marker that opens a line has nothing to attach to.
+    expect(keys(source, 'クリックで "x"を\nに 置く', 'ja')).toEqual([]);
+    // Not in a language whose markers are words (es `a`), nor in qu's yet.
+    expect(keys(source, 'al clic poner "x" en #out', 'es')).toEqual([]);
+    expect(keys(source, 'maykama ñitiy "x" ta #out man churay', 'qu')).toEqual([]);
   });
 });
 
@@ -328,8 +440,8 @@ describe('M2 exit targets', () => {
 
   it('allows no event and no pronoun case, and skips a lane with no render', () => {
     const rates = leakRatesByLanguage(rows({ ru: ['event'], pl: ['case'], he: 'none' }), 'shapes');
-    expect(rates.get('ru')!.met).toEqual({ word: true, event: false, case: true });
-    expect(rates.get('pl')!.met).toEqual({ word: true, event: true, case: false });
+    expect(rates.get('ru')!.met).toEqual({ word: true, event: false, case: true, spacing: true });
+    expect(rates.get('pl')!.met).toEqual({ word: true, event: true, case: false, spacing: true });
     expect(rates.has('he')).toBe(false);
   });
 

package/src/multilingual/english-leaks.ts

@@ -7,7 +7,7 @@
  * passes all of them. Measured 2026-10-08, 18% of corpus renders and 24% of
  * the command-shape scripts' renders hold at least one English word.
  *
- * This gate counts three kinds of finding in a render of English `source`
+ * This gate counts four kinds of finding in a render of English `source`
  * into a language:
  *   - `word`   an English word the engine reads as grammar in the source (or a
  *              reference: `me`, `my`, `I`, `it`, …), written as English in the
@@ -15,8 +15,12 @@
  *   - `event`  an event the source handles or sends, written in English where
  *              the language's lexicon has a word for it and the pair is not on
  *              the renderer's denylist (OPEN_ITEMS N2);
- *   - `case`   the language's nominative `me` next to a role marker, in the
- *              languages where that form is wrong (N3, see CASE_LANGUAGES).
+ *   - `case`   the language's nominative `me` or `it` next to a role marker,
+ *              or as a command's unmarked object, in the languages where that
+ *              form is wrong (N3, see CASE_RULES);
+ *   - `spacing` a marker the language attaches to its noun, written as its
+ *              own word after one (ko `#out 에`, tr `#out e`; N5, see
+ *              ATTACHED_MARKERS).
  *
  * ## What counts as English
  * Derived, never a hand list. A source's grammar words are the tokens the
@@ -66,12 +70,17 @@ export type LeakHalf = keyof typeof LEAK_BASELINE_PATHS;
 // Findings
 // ---------------------------------------------------------------------------
 
-export type LeakKind = 'word' | 'event' | 'case';
+export type LeakKind = 'word' | 'event' | 'case' | 'spacing';
 export type LeakContext = 'plain' | 'clause' | 'bracket' | 'call' | 'property';
+export const KINDS: readonly LeakKind[] = ['word', 'event', 'case', 'spacing'];
 
 export interface LeakFinding {
   kind: LeakKind;
-  /** The English word; for `event` the event name; for `case` the pronoun (`me`). */
+  /**
+   * The English word; for `event` the event name; for `case` the pronoun (`me`,
+   * `it`), with `-object` when it is a verb's unmarked object (`me-object`); for
+   * `spacing` the marker.
+   */
   word: string;
   context: LeakContext;
   /** Does the language have its own word for it? */
@@ -106,33 +115,125 @@ export const KEPT_ENGLISH: {
   ],
 };
 
-/** A finding as the baseline writes it: the word, or `event:<name>` / `case:<pronoun>`. */
+/** A finding as the baseline writes it: the word, or `event:<name>` / `case:<pronoun>` / `spacing:<marker>`. */
 export const findingKey = (f: Pick<LeakFinding, 'kind' | 'word'>): string =>
   f.kind === 'word' ? f.word : `${f.kind}:${f.word}`;
 
+/** Where a language's nominative `me` / `it` is the wrong form ({@link CASE_RULES}). */
+export interface CaseRule {
+  /** `me` beside a role marker. */
+  me?: true;
+  /**
+   * `it` beside a role marker: any marker, or only these (pt contracts only
+   * `em`, `de`; the ru/uk/pl demonstrative's accusative is its nominative, so
+   * it is wrong only after a marker that never takes the accusative).
+   */
+  it?: true | readonly string[];
+  /** `me` / `it` as a command's unmarked object, right after its verb. */
+  meObject?: true;
+  itObject?: true;
+}
+
 /**
- * Languages whose `me` word is nominative while a marker next to it wants
- * another case: es `a yo` (a mí), pt `a eu` (a mim), it `a io` (a me), de
- * `zu ich` (zu mir), pl `do ja` (do mnie), ru `к я` (ко мне), uk `до я`
- * (до мене), tr `ben e` (bana), ar `إلى أنا` (إليّ), he `אל אני` (אליי),
- * tl `sa ako` (sa akin), hi `मैं में` (मुझमें), bn `আমি তে` (আমাতে). The other
- * ten are right as written (fr `à moi`, ja `自分 に`, zh/id/ms/vi/th/ko/sw/qu
- * do not inflect the pronoun for case here). OPEN_ITEMS N3.
+ * The languages whose nominative `me` or `it` is the wrong form where a render
+ * writes it (OPEN_ITEMS N3). A finding is `case:me` / `case:it` beside a role
+ * marker, `case:me-object` / `case:it-object` right after a command's verb with
+ * no marker. Wrong → right:
+ *
+ *   ar  إلى أنا → إليّ; إلى هو → إليه; ضع أنا → ضعني; ضع هو → ضعه
+ *   bn  আমি তে → আমাতে
+ *   de  zu ich → zu mir; zu es → dazu, zu ihm; messen ich → messen mich
+ *   es  a yo → a mí; mostrar yo → mostrarme; poner ello → ponerlo
+ *   fr  dans il → dans lui, y; mettre il → le mettre; cacher moi → me cacher
+ *   he  אל אני → אליי
+ *   hi  मैं में → मुझमें; यह में → इसमें
+ *   it  a io → a me; mostrare io → mostrarmi; mettere esso → metterlo
+ *   pl  do ja → do mnie; do to → do tego, z to → z tego; pokaż ja → pokaż mnie
+ *   pt  a eu → a mim; em ele → nele, de ele → dele; mostrar eu → mostrar-me;
+ *       colocar ele → colocá-lo
+ *   ru  к я → ко мне; к это → к этому, из это → из этого; показать я → показать меня
+ *   tl  sa ako → sa akin; sa ito → dito, mula sa ito → mula rito
+ *   tr  ben e → bana; o e → ona
+ *   uk  до я → до мене; до це → до цього, з це → з цього; показати я → показати мене
+ *
+ * Right as written: fr `à moi` (after a preposition); es `ello`, it `esso` and pt `ele` after any
+ * other marker (`a ello`, `a esso`, `a ele`); ru `в это`, uk `в це`, pl `w to`
+ * and `на`/`na` with them, the accusative of a direction (a location wants
+ * `в этом`, which the text cannot tell apart: not counted); tl `bago ito`,
+ * `matapos ito`; the objects de `es`, ru `это`, uk `це`, pl `to`. A pronoun
+ * that opens a parenthesized expression (`auf (es * 2)`) is not the marker's.
+ * Not counted here: he `ב זה` and bn `এটি কে`, whose fault is
+ * the spacing (N5); `you`, which waits on an owner decision (de `dir` is a
+ * plausible variable name). ja, zh, id, ms, vi, th, ko, sw and qu do not
+ * inflect these pronouns for case.
  */
-export const CASE_LANGUAGES: ReadonlySet<string> = new Set([
-  'ar',
-  'bn',
-  'de',
-  'es',
-  'he',
-  'hi',
-  'it',
-  'pl',
-  'pt',
-  'ru',
-  'tl',
-  'tr',
-  'uk',
+export const CASE_RULES: Readonly<Record<string, CaseRule>> = {
+  ar: { me: true, it: true, meObject: true, itObject: true },
+  bn: { me: true },
+  de: { me: true, it: true, meObject: true },
+  es: { me: true, meObject: true, itObject: true },
+  fr: { it: true, meObject: true, itObject: true },
+  he: { me: true },
+  hi: { me: true, it: true },
+  it: { me: true, meObject: true, itObject: true },
+  pl: { me: true, it: ['do', 'z', 'ze', 'od'], meObject: true },
+  pt: { me: true, it: ['em', 'de'], meObject: true, itObject: true },
+  ru: { me: true, it: ['к', 'ко', 'из', 'от', 'с', 'со'], meObject: true },
+  tl: { me: true, it: ['sa', 'mula_sa'] },
+  tr: { me: true, it: true },
+  uk: { me: true, it: ['до', 'з', 'із', 'від'], meObject: true },
+};
+
+/**
+ * The markers each language attaches to the word before them, where a render
+ * that writes them apart reads as broken (OPEN_ITEMS N5, FUSED_FORMS.md §3.3):
+ * a `spacing:<marker>` finding is one of these written as its own word after
+ * another word (`#out 에` → `#out에`, `.active i` → `.active'i`). The case
+ * particles and suffixes only, which attach in the language's own writing; a
+ * postposition that is a word of its own (tr `içinde`, `arasında`, ko `사이`,
+ * `동안`, bn `থেকে`, `মধ্যে`) is spaced there and is not listed. tr's suffixes
+ * are every harmony form its reader takes. qu attaches its suffixes too, but
+ * its reader takes an attached one into the word before (`#outman` is one
+ * selector), so it waits on the reader (FUSED_FORMS.md Q2, Q3).
+ */
+export const ATTACHED_MARKERS: Readonly<Record<string, ReadonlySet<string>>> = {
+  bn: new Set(['কে', 'তে', 'এ']),
+  ja: new Set(['を', 'に', 'へ', 'で', 'の', 'から', 'として', 'の間で']),
+  ko: new Set(['을', '를', '에', '으로', '로', '의', '에서', '부터', '에게']),
+  tr: new Set(
+    [
+      'i ı u ü yi yı yu yü ni nı nu nü',
+      'e a ye ya ne na',
+      'de da te ta',
+      'den dan ten tan',
+      'in ın un ün nin nın nun nün',
+      'le la yle yla',
+    ].flatMap(forms => forms.split(' '))
+  ),
+};
+
+/**
+ * Commands whose next word is not their object: a handler or block head, or a
+ * condition (`if it is empty`, `while it …`).
+ */
+const NOT_OBJECT_HEADS: ReadonlySet<string> = new Set([
+  'on',
+  'if',
+  'unless',
+  'else',
+  'repeat',
+  'for',
+  'while',
+  'when',
+  'init',
+  'behavior',
+  'install',
+  'live',
+  'js',
+  'compound',
+  'eventsource',
+  'socket',
+  'worker',
 ]);
 
 // ---------------------------------------------------------------------------
@@ -210,8 +311,13 @@ interface ProfileLike {
     keywords?: Record<string, string>;
   };
   eventHandler?: Record<string, unknown>;
+  objectClitics?: { forms?: Record<string, string>; attach?: string };
 }
 type LexiconLike = Record<string, Record<string, KeywordTranslationLike> | undefined>;
+interface PatternLike {
+  command: string;
+  template?: { tokens?: ReadonlyArray<{ type: string; value?: string; alternatives?: string[] }> };
+}
 
 const LEXICON_CATEGORIES = ['values', 'expressions', 'logical', 'temporal', 'attributes'] as const;
 
@@ -226,16 +332,20 @@ interface LanguageWords {
   translated: Set<string>;
   /** Events its lexicon names, minus the renderer's denylist for it. */
   events: Set<string>;
-  /** Its `me` word, and its role markers by side. */
+  /** Its `me` and `it` words, its role markers by side, and its command verbs (as word lists). */
   me: string | undefined;
+  it: string | undefined;
   markersBefore: Set<string>;
   markersAfter: Set<string>;
+  verbs: string[][];
 }
 
 function languageWords(
   profile: ProfileLike | undefined,
   lexicon: LexiconLike | undefined,
-  denied: ReadonlySet<string> | undefined
+  denied: ReadonlySet<string> | undefined,
+  commands: readonly string[],
+  patterns: readonly PatternLike[]
 ): LanguageWords {
   const native = new Set<string>();
   const translated = new Set<string>();
@@ -266,6 +376,10 @@ function languageWords(
   // Native form → the English reference it stands for (es `mi` → `me`).
   for (const n of Object.keys(profile?.possessive?.keywords ?? {}))
     for (const w of wordsOf(n)) native.add(w);
+  // A clitic written as its own word (fr `me cacher`) is the language's; one
+  // attached to its verb (es `mostrarme`) never stands alone.
+  if (profile?.objectClitics?.attach === 'before')
+    for (const clitic of Object.values(profile.objectClitics.forms ?? {})) native.add(clitic);
   for (const w of wordsOf(profile?.possessive?.marker)) native.add(w);
   const handler = JSON.stringify(profile?.eventHandler ?? {});
   for (const m of handler.matchAll(
@@ -285,13 +399,29 @@ function languageWords(
   const markersAfter = new Set<string>();
   for (const t of Object.values(profile?.roleMarkers ?? {}))
     for (const w of spellings(t)) (t.position === 'after' ? markersAfter : markersBefore).add(w);
+  // A command's verb: its keyword, and the word its own patterns open with
+  // (de's `hide` pattern writes `verstecke`, its keyword is `verbergen`).
+  const verbForms: string[] = [];
+  for (const command of commands) {
+    const t = profile?.keywords?.[command];
+    if (t && !NOT_OBJECT_HEADS.has(command))
+      verbForms.push(t.primary ?? '', ...(t.alternatives ?? []));
+  }
+  for (const pattern of patterns) {
+    const first = pattern.template?.tokens?.[0];
+    if (!NOT_OBJECT_HEADS.has(pattern.command) && first?.type === 'literal')
+      verbForms.push(first.value ?? '', ...(first.alternatives ?? []));
+  }
+  const verbs = [...new Set(verbForms.filter(Boolean))].map(wordsOf);
   return {
     native,
     translated,
     events,
     me: profile?.references?.me,
+    it: profile?.references?.it,
     markersBefore,
     markersAfter,
+    verbs,
   };
 }
 
@@ -389,6 +519,8 @@ interface SemanticModule {
   tryGetProfile(language: string): unknown;
   getLexicon(language: string): unknown;
   getEventLocalizationDenylist(): Record<string, ReadonlySet<string>>;
+  commandSchemas: Record<string, unknown>;
+  getPatternsForLanguage(language: string): PatternLike[];
 }
 
 /** Load the engine and semantic (ESM-only, so imported here) and return a scanner. */
@@ -397,6 +529,7 @@ export async function initLeakScanner(): Promise<LeakScanner> {
   engine.register(...engine.everything);
   const semantic = (await import('@lokascript/semantic')) as unknown as SemanticModule;
   const denylist = semantic.getEventLocalizationDenylist();
+  const commands = Object.keys(semantic.commandSchemas);
   const languages = new Map<string, LanguageWords>();
   for (const language of FOREIGN_LANGUAGES) {
     languages.set(
@@ -404,7 +537,9 @@ export async function initLeakScanner(): Promise<LeakScanner> {
       languageWords(
         semantic.tryGetProfile(language) as ProfileLike | undefined,
         semantic.getLexicon(language) as LexiconLike | undefined,
-        denylist[language]
+        denylist[language],
+        commands,
+        semantic.getPatternsForLanguage(language)
       )
     );
   }
@@ -532,14 +667,44 @@ export async function initLeakScanner(): Promise<LeakScanner> {
           ...(isKept(offset, context) ? { kept: true as const } : {}),
         });
       }
-      if (CASE_LANGUAGES.has(language) && lang.me) {
+      const rule = CASE_RULES[language];
+      if (rule) {
         const tokens = words.map(w => w.word);
+        const afterVerb = (i: number): boolean =>
+          lang.verbs.some(
+            verb => i >= verb.length && verb.every((w, k) => tokens[i - verb.length + k] === w)
+          );
         for (let i = 0; i < tokens.length; i++) {
-          if (tokens[i] !== lang.me) continue;
+          const pronoun = tokens[i] === lang.me ? 'me' : tokens[i] === lang.it ? 'it' : undefined;
+          if (!pronoun || /[([]/.test(text[words[i]!.offset - 1] ?? '')) continue;
           const before = tokens[i - 1];
           const after = tokens[i + 1];
-          if ((before && lang.markersBefore.has(before)) || (after && lang.markersAfter.has(after)))
-            findings.push({ kind: 'case', word: 'me', context: 'plain', hasWord: true });
+          const marker =
+            before && lang.markersBefore.has(before)
+              ? before
+              : after && lang.markersAfter.has(after)
+                ? after
+                : undefined;
+          const wrong = rule[pronoun];
+          const wrongBeside =
+            marker !== undefined && (wrong === true || (!!wrong && wrong.includes(marker)));
+          const wrongObject = !!rule[`${pronoun}Object`] && afterVerb(i);
+          if (wrongBeside || wrongObject)
+            findings.push({
+              kind: 'case',
+              word: wrongObject ? `${pronoun}-object` : pronoun,
+              context: 'plain',
+              hasWord: true,
+            });
+        }
+      }
+      const attached = ATTACHED_MARKERS[language];
+      if (attached) {
+        for (const { word, offset } of words) {
+          if (!attached.has(word)) continue;
+          // After a word on its line, strings included (`"x" 을`): the render, not the code.
+          const before = /(\S)[^\S\n]+$/.exec(render.slice(0, offset));
+          if (before) findings.push({ kind: 'spacing', word, context: 'plain', hasWord: true });
         }
       }
       return findings;
@@ -597,6 +762,7 @@ export function leakBaselineFrom(results: LeakResults, description: string): Lea
       word: { renders: 0, findings: 0 },
       event: { renders: 0, findings: 0 },
       case: { renders: 0, findings: 0 },
+      spacing: { renders: 0, findings: 0 },
     },
     entries: {},
     unrendered: {},
@@ -613,7 +779,7 @@ export function leakBaselineFrom(results: LeakResults, description: string): Lea
       if (!findings.length) continue;
       doc.leaky++;
       doc.findings += findings.length;
-      for (const kind of ['word', 'event', 'case'] as const) {
+      for (const kind of KINDS) {
         const n = findings.filter(f => f.kind === kind).length;
         doc.kinds[kind].findings += n;
         if (n) doc.kinds[kind].renders++;
@@ -711,15 +877,14 @@ export function loadLeakBaseline(half: LeakHalf): LeakBaseline {
  * reader reads one, and an average hid he (35% of corpus renders with an English
  * word where the others sit near 18%). Words count only English no recorded
  * decision keeps ({@link KEPT_ENGLISH}). Events are already net of the denylist,
- * whose entries carry reasons.
+ * whose entries carry reasons. Spacing (N5) joined on 2026-10-11, with none
+ * allowed, as case did (FUSED_FORMS.md Q3).
  */
 export const LEAK_TARGETS: Readonly<Record<LeakHalf, Readonly<Record<LeakKind, number>>>> = {
-  corpus: { word: 0.05, event: 0, case: 0 },
-  shapes: { word: 0.1, event: 0, case: 0 },
+  corpus: { word: 0.05, event: 0, case: 0, spacing: 0 },
+  shapes: { word: 0.1, event: 0, case: 0, spacing: 0 },
 };
 
-const KINDS: readonly LeakKind[] = ['word', 'event', 'case'];
-
 export interface LanguageLeakRates {
   renders: number;
   /** The share of the language's renders with a finding of each kind. */
@@ -737,7 +902,7 @@ export function leakRatesByLanguage(
   for (const byLanguage of results.values()) {
     for (const [language, findings] of byLanguage) {
       if (!findings) continue;
-      const row = counts.get(language) ?? { renders: 0, word: 0, event: 0, case: 0 };
+      const row = counts.get(language) ?? { renders: 0, word: 0, event: 0, case: 0, spacing: 0 };
       row.renders++;
       for (const kind of KINDS) if (findings.some(f => f.kind === kind && !f.kept)) row[kind]++;
       counts.set(language, row);
@@ -745,8 +910,8 @@ export function leakRatesByLanguage(
   }
   const out = new Map<string, LanguageLeakRates>();
   for (const [language, row] of counts) {
-    const rate = { word: 0, event: 0, case: 0 };
-    const met = { word: true, event: true, case: true };
+    const rate = { word: 0, event: 0, case: 0, spacing: 0 };
+    const met = { word: true, event: true, case: true, spacing: true };
     for (const kind of KINDS) {
       rate[kind] = row[kind] / row.renders;
       met[kind] = rate[kind] <= LEAK_TARGETS[half][kind];

package/src/multilingual/hand-written-input.tasks.json

@@ -0,0 +1,162 @@
+[
+ {
+  "id": "t01",
+  "ask": "When the button is clicked, toggle the class \"active\" on it.",
+  "source": "on click toggle .active on me",
+  "fixture": "<button></button>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t02",
+  "ask": "When the button is clicked, put the text Saved into the element with id out.",
+  "source": "on click put \"Saved\" into #out",
+  "fixture": "<button></button><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t03",
+  "ask": "When the button is clicked, hide the element with id panel.",
+  "source": "on click hide #panel",
+  "fixture": "<button></button><div id=\"panel\">x</div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t04",
+  "ask": "When the button is clicked, add the class \"open\" to the element with id menu, then remove its class \"closed\".",
+  "source": "on click add .open to #menu then remove .closed from #menu",
+  "fixture": "<button></button><div id=\"menu\" class=\"closed\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t05",
+  "ask": "When the button is clicked, fetch /api/greeting and put the result into the element with id out.",
+  "source": "on click fetch /api/greeting then put it into #out",
+  "fixture": "<button></button><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t06",
+  "ask": "When the button is clicked: if it has the class \"on\", remove that class; otherwise add it.",
+  "source": "on click if I match .on remove .on else add .on end",
+  "fixture": "<button class=\"on\"></button>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t07",
+  "ask": "When the button is clicked, append the text \"x\" to the element with id out three times.",
+  "source": "on click repeat 3 times append \"x\" to #out end",
+  "fixture": "<button></button><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t08",
+  "ask": "When the button is clicked, send a custom event named refresh to the element with id list, then add the class \"sent\" to the button.",
+  "source": "on click send refresh to #list then add .sent to me",
+  "fixture": "<button></button><ul id=\"list\"></ul>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t09",
+  "ask": "When the button is clicked, set the variable $n to 5 and put it into the element with id out.",
+  "source": "on click set $n to 5 then put $n into #out",
+  "fixture": "<button></button><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t10",
+  "ask": "When the button is clicked, increase the variable $count by one and put it into the element with id out.",
+  "source": "on click increment $count then put $count into #out",
+  "fixture": "<button></button><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t11",
+  "ask": "Define a behavior named Hider that hides the element when it is clicked (the page installs it on the button with: install Hider).",
+  "source": "behavior Hider\n  on click hide me end\nend",
+  "fixture": "<button></button>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t12",
+  "ask": "When the input receives input, put its value into the element with id out.",
+  "source": "on input put my value into #out",
+  "fixture": "<input value=\"hi\"><div id=\"out\"></div>",
+  "installOn": "input",
+  "event": "input"
+ },
+ {
+  "id": "t13",
+  "ask": "When the button is clicked, put the value of the input with id field into the element with id out.",
+  "source": "on click put the value of #field into #out",
+  "fixture": "<button></button><input id=\"field\" value=\"abc\"><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t14",
+  "ask": "When the button is clicked, add the class \"sel\" to the first list item inside the element with id list.",
+  "source": "on click add .sel to the first <li/> in #list",
+  "fixture": "<button></button><ul id=\"list\"><li>a</li><li>b</li></ul>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t15",
+  "ask": "When the button is clicked, set its attribute aria-expanded to \"true\".",
+  "source": "on click set @aria-expanded to \"true\"",
+  "fixture": "<button aria-expanded=\"false\"></button>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t16",
+  "ask": "When the button is clicked, put the text \"x\" at the end of the element with id out.",
+  "source": "on click put \"x\" at end of #out",
+  "fixture": "<button></button><div id=\"out\">start</div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t17",
+  "ask": "When the button is clicked, for every element with the class \"item\", add the class \"seen\" to it.",
+  "source": "on click for item in .item add .seen to item end",
+  "fixture": "<button></button><p class=\"item\"></p><p class=\"item\"></p>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t18",
+  "ask": "When the button is clicked, if there is no element with class \"item\" inside the element with id list, put the text \"empty\" into the element with id out.",
+  "source": "on click if no .item in #list put \"empty\" into #out end",
+  "fixture": "<button></button><ul id=\"list\"></ul><div id=\"out\"></div>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t19",
+  "ask": "When the button is clicked, take the class \"selected\" from whichever element with class \"tab\" has it, and give it to the button.",
+  "source": "on click take .selected from .tab for me",
+  "fixture": "<button class=\"tab\"></button><a class=\"tab selected\"></a>",
+  "installOn": "button",
+  "event": "click"
+ },
+ {
+  "id": "t20",
+  "ask": "When the button is clicked, remove the button.",
+  "source": "on click remove me",
+  "fixture": "<button></button>",
+  "installOn": "button",
+  "event": "click"
+ }
+]

package/src/multilingual/hand-written-input.test.ts

@@ -0,0 +1,62 @@
+/**
+ * The hand-written-input gate: see hand-written-input.ts.
+ *
+ * @vitest-environment node
+ * Required, not a preference: the hosts bind the jsdom window's DOM
+ * constructors (see shipped-examples-execution.test.ts).
+ */
+import { describe, it, expect, beforeAll } from 'vitest';
+import {
+  formatReport,
+  loadInputs,
+  loadTasks,
+  runHandWritten,
+  type HandWrittenReport,
+} from './hand-written-input';
+
+describe('hand-written inputs', () => {
+  let report: HandWrittenReport;
+
+  beforeAll(async () => {
+    report = await runHandWritten();
+    console.log(formatReport(report));
+  }, 300_000);
+
+  it('has about twenty tasks, each with a reference, a fixture and an event', () => {
+    const tasks = loadTasks();
+    expect(tasks.length).toBeGreaterThanOrEqual(18);
+    expect(tasks.length).toBeLessThanOrEqual(25);
+    for (const t of tasks) {
+      expect(t.ask.length).toBeGreaterThan(10);
+      expect(t.fixture).toContain('<');
+      expect(t.event).toBeTruthy();
+    }
+    expect(new Set(tasks.map(t => t.id)).size).toBe(tasks.length);
+  });
+
+  it('every reference runs the same on upstream and the engine, and does something', () => {
+    const bad = report.references.filter(r => !r.holds);
+    expect(bad.map(r => `${r.task}: upstream ${r.want} | engine ${r.eng}`)).toEqual([]);
+  });
+
+  it('every input names a task', () => {
+    expect(report.unknownTasks).toEqual([]);
+  });
+
+  it('every input file is valid JSON of {task, source, writer} rows', () => {
+    for (const rows of Object.values(loadInputs())) {
+      for (const r of rows) {
+        expect(typeof r.task).toBe('string');
+        expect(typeof r.source).toBe('string');
+      }
+    }
+  });
+
+  // No input is seeded here (a render of ours would measure nothing). Once
+  // native speakers' files exist, this is where a verdict is held: a `silent`
+  // input is a reader bug (the writer was told nothing), to fix or to list.
+  it('no hand-written input is silent', () => {
+    const silent = report.results.filter(r => r.verdict === 'silent');
+    expect(silent.map(r => `${r.lang} ${r.task} ${r.source}`)).toEqual([]);
+  });
+});

package/src/multilingual/hand-written-input.ts

@@ -0,0 +1,201 @@
+/**
+ * The hand-written-input gate (M2, reliability row 6).
+ *
+ * Every other multilingual gate reads what OUR renderer writes. This one reads
+ * what a native speaker writes: about twenty tasks (`hand-written-input.tasks.json`),
+ * each an English reference source with a fixture and an event, and one input
+ * file per language under `hand-written-inputs/` holding the sources a native
+ * speaker wrote from the task's English description and the language's word
+ * list, without seeing our renders. Each input runs AS WRITTEN on
+ * `@hyperfixi/engine` with the adapter (direct-path-shapes.ts's hosts), against
+ * upstream `_hyperscript` running the English reference.
+ *
+ * Per task and language the verdict is one of:
+ *   - `accepted`: the input ran and left the DOM the reference leaves;
+ *   - `refused`:  the adapter refused the input (translate threw: the writer is told);
+ *   - `silent`:   the input ran, or the engine rejected it, with another result.
+ *
+ * NEVER seed the inputs with our renders: the gate would then measure nothing.
+ * With no inputs it reports "no inputs yet" and still checks the references
+ * (upstream and the engine run each English source identically).
+ *
+ * The writer's instructions: `docs-internal/multilingual/HAND_WRITTEN_INPUT.md`.
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  initDirectPathHosts,
+  type DirectPathCase,
+  type DirectPathHosts,
+  type PairResult,
+} from './direct-path-shapes';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+export const TASKS_FILE = path.join(here, 'hand-written-input.tasks.json');
+export const INPUTS_DIR = path.resolve(here, '../../hand-written-inputs');
+
+export interface HandWrittenTask extends DirectPathCase {
+  /** What the writer is asked to make the page do, in plain English. */
+  ask: string;
+}
+
+interface TaskRow {
+  id: string;
+  ask: string;
+  source: string;
+  fixture: string;
+  installOn: string;
+  event: string;
+}
+
+export function loadTasks(): HandWrittenTask[] {
+  const rows = JSON.parse(readFileSync(TASKS_FILE, 'utf8')) as TaskRow[];
+  return rows.map(t => {
+    const behavior = /^behavior\s+(\w+)/.exec(t.source);
+    return {
+      id: `hand-written#${t.id}`,
+      ask: t.ask,
+      source: t.source,
+      fixture: t.fixture,
+      installOn: t.installOn,
+      event: t.event,
+      languages: [],
+      ...(behavior ? { behaviorName: behavior[1] } : {}),
+    };
+  });
+}
+
+export interface HandWrittenInput {
+  /** The task's id as the tasks file spells it (`t01`). */
+  task: string;
+  /** The hyperscript the writer wrote, in their language. */
+  source: string;
+  /** Who wrote it (a name or initials; one file may hold several writers). */
+  writer?: string;
+}
+
+/** `hand-written-inputs/<lang>.json`: `[{ "task": "t01", "source": "…", "writer": "…" }]`. */
+export function loadInputs(dir = INPUTS_DIR): Record<string, HandWrittenInput[]> {
+  const inputs: Record<string, HandWrittenInput[]> = {};
+  if (!existsSync(dir)) return inputs;
+  for (const file of readdirSync(dir).sort()) {
+    const m = /^([a-z]{2})\.json$/.exec(file);
+    if (!m) continue;
+    const rows = JSON.parse(readFileSync(path.join(dir, file), 'utf8')) as HandWrittenInput[];
+    inputs[m[1]!] = rows.filter(r => typeof r.source === 'string' && r.source.trim() !== '');
+  }
+  return inputs;
+}
+
+export type Verdict = 'accepted' | 'refused' | 'silent';
+
+export interface HandWrittenResult {
+  task: string;
+  lang: string;
+  writer: string;
+  source: string;
+  verdict: Verdict;
+  pair: PairResult;
+}
+
+export function verdictOf(pair: PairResult): Verdict {
+  if (pair.ok) return 'accepted';
+  if (pair.english.startsWith('✗')) return 'refused';
+  return 'silent';
+}
+
+export interface ReferenceCheck {
+  task: string;
+  want: string;
+  eng: string;
+  holds: boolean;
+}
+
+export interface HandWrittenReport {
+  references: ReferenceCheck[];
+  results: HandWrittenResult[];
+  /** Tasks the inputs name that the tasks file does not. */
+  unknownTasks: string[];
+}
+
+/**
+ * Run every input against its task. `hosts` may be shared with another gate;
+ * when omitted, one is opened and closed here.
+ */
+export async function runHandWritten(
+  inputs = loadInputs(),
+  hosts?: DirectPathHosts
+): Promise<HandWrittenReport> {
+  const tasks = loadTasks();
+  const own = hosts ?? (await initDirectPathHosts());
+  try {
+    const references: ReferenceCheck[] = [];
+    for (const task of tasks) {
+      const r = await own.runCase(task);
+      references.push({
+        task: task.id,
+        want: r.want,
+        eng: r.eng,
+        holds: !r.want.startsWith('✗') && !/^∅( ‖ ∅)*$/.test(r.want) && r.eng === r.want,
+      });
+    }
+    const results: HandWrittenResult[] = [];
+    const unknownTasks: string[] = [];
+    for (const [lang, rows] of Object.entries(inputs)) {
+      for (const row of rows) {
+        const task = tasks.find(t => t.id === `hand-written#${row.task}`);
+        if (!task) {
+          unknownTasks.push(`${lang}:${row.task}`);
+          continue;
+        }
+        const pair = await own.runWritten(task, lang, row.source);
+        results.push({
+          task: task.id,
+          lang,
+          writer: row.writer ?? '',
+          source: row.source,
+          verdict: verdictOf(pair),
+          pair,
+        });
+      }
+    }
+    return { references, results, unknownTasks };
+  } finally {
+    if (!hosts) await own.close();
+  }
+}
+
+/** The report, per task and language, as text. */
+export function formatReport(report: HandWrittenReport): string {
+  const lines: string[] = [];
+  const bad = report.references.filter(r => !r.holds);
+  lines.push(
+    `references: ${report.references.length - bad.length}/${report.references.length} run the same on upstream and the engine` +
+      (bad.length ? ` (NOT: ${bad.map(r => r.task).join(', ')})` : '')
+  );
+  if (report.results.length === 0) {
+    lines.push('hand-written inputs: no inputs yet (hand-written-inputs/<lang>.json)');
+    return lines.join('\n');
+  }
+  const langs = [...new Set(report.results.map(r => r.lang))].sort();
+  const counts: Record<Verdict, number> = { accepted: 0, refused: 0, silent: 0 };
+  for (const r of report.results) counts[r.verdict]++;
+  lines.push(
+    `hand-written inputs: ${report.results.length} from ${langs.length} language(s): ` +
+      `${counts.accepted} accepted, ${counts.refused} refused, ${counts.silent} silent`
+  );
+  for (const lang of langs) {
+    const rows = report.results.filter(r => r.lang === lang);
+    const c: Record<Verdict, number> = { accepted: 0, refused: 0, silent: 0 };
+    for (const r of rows) c[r.verdict]++;
+    lines.push(`  ${lang}: ${c.accepted} accepted, ${c.refused} refused, ${c.silent} silent`);
+    for (const r of rows.filter(x => x.verdict !== 'accepted')) {
+      lines.push(`    ${r.verdict.padEnd(8)} ${r.task.replace('hand-written#', '')} ${JSON.stringify(r.source)}`);
+      if (r.verdict === 'silent') lines.push(`             got ${r.pair.got} | want ${r.pair.ref}`);
+    }
+  }
+  if (report.unknownTasks.length) lines.push(`unknown tasks: ${report.unknownTasks.join(', ')}`);
+  return lines.join('\n');
+}

package/src/vocab/batch3-roundtrip.test.ts

@@ -127,7 +127,8 @@ describe('Batch 3 — wrong-verb class (dict word was another command)', () => {
 describe('Batch 3 — it blur (noun form dropped the command patient)', () => {
   it('it: blur command render captures blur.patient', () => {
     const { render, triples: t } = renderAndParse('on keydown[key=="Escape"] blur me', 'it');
-    expect(render).toContain('sfuocare');
+    // The verb, not the noun; with its object attached since M2 N3 (`sfuocarmi`).
+    expect(render).toMatch(/sfuocar(?:e|mi)\b/);
     expect(t).toContain('blur.patient=me');
   });