@hyperfixi/testing-framework 4.0.1 → 4.2.0

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

@@ -376,8 +376,15 @@ export async function initDirectPathHosts(): Promise<DirectPathHosts> {
     for (const steps of scriptOf(c)) parts.push(await run(host, c, code, lang, steps));
     return parts.join(' ‖ ');
   };
-  const rejects = (host: ScriptHost, code: string): string | undefined =>
-    host.parse(code)?.errors?.[0]?.message.split('\n')[0];
+  // Two failure channels: parse errors, and the tokenizer THROWING on a
+  // character it does not know (the text a refused translation leaves as written).
+  const rejects = (host: ScriptHost, code: string): string | undefined => {
+    try {
+      return host.parse(code)?.errors?.[0]?.message.split('\n')[0];
+    } catch (e) {
+      return (e as Error).message.split('\n')[0] ?? 'threw';
+    }
+  };
 
   return {
     async runCase(c) {

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

@@ -4,7 +4,7 @@
  * leaves out; the matrix shards run the names themselves.
  */
 import { describe, it, expect } from 'vitest';
-import { collidingNames, generateCells } from './value-matrix';
+import { KEYWORD_NAMES, collidingNames, generateCells } from './value-matrix';
 
 const names = new Map(collidingNames().map(entry => [entry.name, entry]));
 
@@ -29,6 +29,16 @@ describe('value matrix: colliding names', () => {
     expect(names.has('an')).toBe(true);
   });
 
+  // Upstream runs each as a variable; English's own parse dropped `set input
+  // to "a"`, and every language wrote `when` as its keyword (P49).
+  it('takes the English words upstream runs as variables (KEYWORD_NAMES)', () => {
+    for (const name of KEYWORD_NAMES) expect(names.has(name), name).toBe(true);
+    expect(KEYWORD_NAMES).toContain('input'); // an event name
+    expect(KEYWORD_NAMES).toContain('when'); // a structure word
+    expect(KEYWORD_NAMES).toContain('index'); // a value-lexicon word (P28)
+    expect(names.has('if')).toBe(false); // P53
+  });
+
   it("leaves out upstream's `no` and the templates' variables", () => {
     expect(names.has('no')).toBe(false);
     expect(names.has('i')).toBe(false);

package/src/multilingual/value-matrix.ts

@@ -550,6 +550,30 @@ let collidingNamesMemo: readonly CollidingName[] | undefined;
  */
 const CODE_NAMES: readonly string[] = ['userData'];
 
+/**
+ * Names spelled like English vocabulary that upstream and the engine run as
+ * variables where a value stands: event names, which every tokenizer reads as
+ * an event (`set input to "a"` dropped from English's own parse), structure
+ * words (`when`, which every language wrote as its keyword), and words of the
+ * value lexicon (`index`, which bn and four others wrote natively) — P49, P28.
+ * Not a name the window already holds (`focus`, `length`), nor `then`: the
+ * fixture sets each name there, and a `then` on the window makes upstream
+ * take it for a promise. Not yet `if` or `end`, which open and close a block
+ * in every language's reader (OPEN_ITEMS P53: 93 and 505 failing pairs).
+ */
+export const KEYWORD_NAMES: readonly string[] = [
+  'click',
+  'input',
+  'change',
+  'keyup',
+  'submit',
+  'load',
+  'drop',
+  'when',
+  'index',
+  'value',
+];
+
 /**
  * Variables spelled like a structure word of a language the matrix translates
  * into: every one- or two-letter name semantic's `nameCollision` finds
@@ -580,14 +604,15 @@ export function collidingNames(): readonly CollidingName[] {
     const tokens = tokenize(word, 'en').tokens;
     return tokens.length === 1 && tokens[0]?.kind !== 'identifier';
   };
-  collidingNamesMemo = candidates
-    .filter(word => !reserved.has(word) && !englishKeyword(word))
+  collidingNamesMemo = [...new Set([...candidates, ...KEYWORD_NAMES])]
+    .filter(word => !reserved.has(word) && (KEYWORD_NAMES.includes(word) || !englishKeyword(word)))
     .flatMap(name => {
       const readings = FOREIGN_LANGUAGES.map(language => ({
         language,
         collision: nameCollision(name, language),
       }));
-      if (!readings.some(reading => reading.collision === 'structure')) return [];
+      const structure = readings.some(reading => reading.collision === 'structure');
+      if (!structure && !KEYWORD_NAMES.includes(name)) return [];
       const pronounIn = readings.filter(r => r.collision === 'pronoun').map(r => r.language);
       return [{ name, pronounIn }];
     });