@hyperfixi/testing-framework 4.4.0 → 4.6.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];