@hyperfixi/testing-framework 4.3.0 → 4.5.0

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