@hyperfixi/testing-framework 3.3.0 → 4.0.1

package/src/multilingual/shipped-examples-execution.test.ts

@@ -3,25 +3,25 @@
  * why and the execution model).
  *
  * Executes every eligible `_="…"` handler shipped in `examples/**` on BOTH
- * hyperfixi and the real `hyperscript.org` engine, in jsdom, and ratchets on
- * divergence of their DOM effect signatures. Upstream is the behavioral
- * oracle — the same role R4 gives it for validity. This is the gate that would
- * have caught the #785 defect (a conditional body running unconditionally on a
- * shipped page) on BEHAVIOR: every parse-level gate stayed green while it
- * shipped.
+ * `@hyperfixi/engine` and the real `hyperscript.org` engine, in jsdom, and
+ * ratchets on divergence of their DOM effect signatures. Upstream is the
+ * behavioral oracle — the same role R4 gives it for validity. This is the gate
+ * that would have caught the #785 defect (a conditional body running
+ * unconditionally on a shipped page) on BEHAVIOR: every parse-level gate stayed
+ * green while it shipped. It is also the gate for a handler that parses on both
+ * engines and runs differently, which the parse-level list in
+ * shipped-sources-engine.test.ts cannot see.
  *
  * Assertions, matching the shipped-sources gate:
  *   1. sanity — pages walked, handlers extracted, comparisons actually ran
  *      (guards the silent-zero failure mode);
- *   2. no NEW divergence appears outside the committed allowlist;
+ *   2. no NEW divergence appears outside the committed allowlist
+ *      (`allowedEngineDivergences`);
  *   3. no allowlisted key has silently converged (stale entries must be
  *      removed so the list only ever ratchets down).
  *
- * The same three run for the ENGINE LANE: `@hyperfixi/engine`, the engine meant
- * to replace core's, against the same oracle on every handler upstream accepts
- * (`allowedEngineDivergences` in the same baseline). It is the gate for a
- * handler that parses on both engines and runs differently, which the
- * parse-level list in shipped-sources-engine.test.ts cannot see.
+ * (Until Phase C4 the same three also ran for a lane on `@hyperfixi/core`'s
+ * runtime, against its own allowlist. It left with core's engine.)
  *
  * To update after an intentional change: re-run and regenerate
  * `baselines/shipped-examples-execution.json` (the allowlist key embeds a
@@ -37,8 +37,8 @@
  * (happy-dom) the DOM constructors already exist on globalThis, the harness's
  * globals bootstrap refuses to overwrite what it does not own, and both
  * engines then bind happy-dom's constructors — every instanceof against a
- * jsdom element fails and every hyperfixi signature comes back empty
- * (measured: 0 real matches under happy-dom vs 74 under node).
+ * jsdom element fails and every signature comes back empty
+ * (measured on core's lane: 0 real matches under happy-dom vs 74 under node).
  */
 
 import { readFileSync } from 'node:fs';
@@ -53,14 +53,7 @@ import {
 } from './shipped-examples-execution';
 
 interface AllowlistDoc {
-  allowedDivergences: Array<{
-    key: string;
-    file: string;
-    event: string;
-    excerpt: string;
-    reason: string;
-  }>;
-  /** The engine lane: `@hyperfixi/engine` against upstream. */
+  /** `@hyperfixi/engine` against upstream. */
   allowedEngineDivergences: Array<{
     key: string;
     file: string;
@@ -75,18 +68,13 @@ const baselinePath = path.resolve(
   '../../baselines/shipped-examples-execution.json'
 );
 const allowlist = JSON.parse(readFileSync(baselinePath, 'utf8')) as AllowlistDoc;
-const allowed = new Set(allowlist.allowedDivergences.map(e => e.key));
 const allowedOnEngine = new Set(allowlist.allowedEngineDivergences.map(e => e.key));
 
-/** One sweep, shared by both lanes' tests. */
-let sweeping: Promise<ExecutionParityResult> | undefined;
-const sweep = (): Promise<ExecutionParityResult> => (sweeping ??= runShippedExamplesExecution());
-
-describe('shipped-examples execution gate', () => {
+describe('shipped-examples execution gate: @hyperfixi/engine against upstream', () => {
   let result: ExecutionParityResult;
 
   beforeAll(async () => {
-    result = await sweep();
+    result = await runShippedExamplesExecution();
 
     // Visibility, not assertions: what the sweep could not compare, and why.
     // A silently shrinking denominator is this gate's own blind spot.
@@ -95,26 +83,21 @@ describe('shipped-examples execution gate', () => {
       const r = s.reason.split(':')[0] ?? s.reason;
       reasons.set(r, (reasons.get(r) ?? 0) + 1);
     }
-    const vacuous = result.compared.filter(c => c.vacuous).length;
+    const onEngine = result.engineCompared;
     console.log(
       `[shipped-examples-execution] pages=${result.pages} handlers=${result.handlers} ` +
-        `compared=${result.compared.length} (vacuous=${vacuous}) skipped=${result.skipped.length}`
+        `compared=${onEngine.length} (vacuous=${onEngine.filter(c => c.vacuous).length}) ` +
+        `diverging=${onEngine.filter(c => !c.match).length} skipped=${result.skipped.length}`
     );
     for (const [r, n] of [...reasons].sort((a, b) => b[1] - a[1])) {
       console.log(`[shipped-examples-execution]   skip ×${n}: ${r}`);
     }
-    const onEngine = result.engineCompared;
-    console.log(
-      `[shipped-examples-execution] engine lane: compared=${onEngine.length} ` +
-        `(vacuous=${onEngine.filter(c => c.vacuous).length}) ` +
-        `diverging=${onEngine.filter(c => !c.match).length}`
-    );
   }, 240_000);
 
   it('walks pages and compares handlers (sanity: extraction and both engines working)', () => {
-    // Floors well below current values (48 / 261 / 122 / 52) but far above
-    // zero: a broken walk, extractor, or engine bootstrap fails loudly here
-    // instead of making assertions 2-3 vacuously pass.
+    // Floors well below current values but far above zero: a broken walk,
+    // extractor, or engine bootstrap fails loudly here instead of making
+    // assertions 2-3 vacuously pass.
     //
     // Calibrated against the git-TRACKED corpus — the sweep ignores untracked
     // examples/ dirs, so these numbers are the same on every machine and in
@@ -122,59 +105,9 @@ describe('shipped-examples execution gate', () => {
     // gitignored dirs present and failed every clean checkout — #862.)
     expect(result.pages).toBeGreaterThan(35);
     expect(result.handlers).toBeGreaterThan(200);
-    expect(result.compared.length).toBeGreaterThan(90);
+    expect(result.engineCompared.length).toBeGreaterThan(90);
     // Vacuous (empty-vs-empty) pairs are NOT parity evidence — the floor is on
     // real, non-empty signature matches.
-    const realMatches = result.compared.filter(c => c.match && !c.vacuous).length;
-    expect(realMatches).toBeGreaterThan(40);
-  });
-
-  it('has no NEW divergence from upstream outside the allowlist', () => {
-    const unexpected = result.compared.filter(c => !c.match && !allowed.has(c.key));
-    expect(
-      unexpected,
-      unexpected.length
-        ? `\nShipped handlers whose DOM effect DIVERGES from the hyperscript.org engine ` +
-            `(fix the behavior, or allowlist with a family reason):\n` +
-            unexpected
-              .map(
-                f =>
-                  `  [${f.key}]\n` +
-                  `      "${f.excerpt}"\n` +
-                  `      hyperfixi: ${JSON.stringify(f.hyperfixiEffects).slice(0, 300)}\n` +
-                  `      upstream : ${JSON.stringify(f.upstreamEffects).slice(0, 300)}`
-              )
-              .join('\n') +
-            `\n\nTriage guidance: an EMPTY hyperfixi signature with a non-empty upstream one usually\n` +
-            `means hyperfixi silently dropped behavior (the #785 class). The reverse often means a\n` +
-            `deliberate hyperfixi extension or a jsdom limitation on the upstream side — check the\n` +
-            `existing family reasons in baselines/shipped-examples-execution.json before adding a new one.`
-        : ''
-    ).toEqual([]);
-  });
-
-  it('has no stale allowlist entries (a now-converged handler must be removed so the list ratchets down)', () => {
-    const stillDiverging = new Set(result.compared.filter(c => !c.match).map(c => c.key));
-    const stale = allowlist.allowedDivergences.map(e => e.key).filter(k => !stillDiverging.has(k));
-    expect(
-      stale,
-      stale.length
-        ? `\nThese allowlisted handlers no longer diverge (fixed, or edited — the key embeds a\n` +
-            `source hash; or no longer eligible, in which case the coverage loss should be deliberate).\n` +
-            `Remove them from baselines/shipped-examples-execution.json:\n  ${stale.join('\n  ')}`
-        : ''
-    ).toEqual([]);
-  });
-});
-
-describe('shipped-examples execution gate: @hyperfixi/engine against upstream', () => {
-  let result: ExecutionParityResult;
-  beforeAll(async () => {
-    result = await sweep();
-  }, 240_000);
-
-  it('compares handlers on the engine (sanity: the lane ran and mostly agrees)', () => {
-    expect(result.engineCompared.length).toBeGreaterThan(90);
     const realMatches = result.engineCompared.filter(c => c.match && !c.vacuous).length;
     expect(realMatches).toBeGreaterThan(60);
   });
@@ -196,12 +129,14 @@ describe('shipped-examples execution gate: @hyperfixi/engine against upstream',
                   `      upstream: ${JSON.stringify(f.upstreamEffects).slice(0, 300)}`
               )
               .join('\n') +
-            `\n\nOne source on both, on one page: npx tsx packages/engine/tools/probe.mts '<source>'`
+            `\n\nTriage guidance: an EMPTY engine signature with a non-empty upstream one usually\n` +
+            `means the engine silently dropped behavior (the #785 class).\n` +
+            `One source on both, on one page: npx tsx packages/engine/tools/probe.mts '<source>'`
         : ''
     ).toEqual([]);
   });
 
-  it('has no stale allowlist entries', () => {
+  it('has no stale allowlist entries (a now-converged handler must be removed so the list ratchets down)', () => {
     const stillDiverging = new Set(result.engineCompared.filter(c => !c.match).map(c => c.key));
     const stale = allowlist.allowedEngineDivergences
       .map(e => e.key)
@@ -209,9 +144,10 @@ describe('shipped-examples execution gate: @hyperfixi/engine against upstream',
     expect(
       stale,
       stale.length
-        ? `\nThese handlers no longer diverge on the engine (or were edited: the key embeds a\n` +
-            `source hash). Remove them from allowedEngineDivergences in\n` +
-            `baselines/shipped-examples-execution.json:\n  ${stale.join('\n  ')}`
+        ? `\nThese handlers no longer diverge on the engine (fixed, or edited — the key embeds a\n` +
+            `source hash; or no longer eligible, in which case the coverage loss should be deliberate).\n` +
+            `Remove them from allowedEngineDivergences in baselines/shipped-examples-execution.json:\n  ` +
+            stale.join('\n  ')
         : ''
     ).toEqual([]);
   });

package/src/multilingual/shipped-examples-execution.ts

@@ -9,24 +9,27 @@
  *
  * This gate executes the handlers we actually ship. For each `_="…"` attribute
  * in `examples/**`, the full page is loaded into two jsdom instances — one
- * processed by hyperfixi (parse + a fresh Runtime with the element as context,
- * the same shape the browser attribute processor uses), one by the real
- * `hyperscript.org` engine (`processNode`) — the handler's trigger event is
- * dispatched, and the resulting DOM effect signatures (../effect-signature.ts,
- * shared with the R2 execution ratchet) are diffed against each other.
- * Upstream plays the role R4 gives it for validity: the oracle. A divergence
- * means hyperfixi's runtime behavior differs from upstream's ON A SHIPPED
- * PAGE — exactly the #785/#786 failure mode, caught on behavior instead of by
- * luck.
+ * processed by `@hyperfixi/engine`, one by the real `hyperscript.org` engine
+ * (`processNode` on both) — the handler's trigger event is dispatched, and the
+ * resulting DOM effect signatures (../effect-signature.ts, shared with the R2
+ * execution ratchet) are diffed against each other. Upstream plays the role R4
+ * gives it for validity: the oracle. A divergence means the engine's runtime
+ * behavior differs from upstream's ON A SHIPPED PAGE — exactly the #785/#786
+ * failure mode, caught on behavior instead of by luck. The parse-level list of
+ * what the engine rejects (shipped-sources-engine.test.ts) cannot see a handler
+ * that parses on both and runs differently; this can. A handler upstream
+ * accepts and the engine rejects is compared too, and diverges.
+ *
+ * (Until Phase C4 a second lane ran each handler on `@hyperfixi/core`'s runtime
+ * against the same oracle. It left with core's engine; its ten allowlisted
+ * divergences were core's.)
  *
  * ## Fair denominator (mirrors R4)
- * A handler is only compared when BOTH engines accept its source: hyperfixi
- * must compile it clean (`ok: true`, no recovered errors — recovering sources
- * are the shipped-sources gate's business) and upstream must parse it (a
- * hyperfixi-only extension has no oracle). It must also be deterministically
- * executable in jsdom: triggered by a dispatchable event, free of network /
- * timer / navigation constructs. Every exclusion is recorded with a reason —
- * the skip list is part of the result, never silent (`no silent caps`).
+ * A handler is only compared when upstream parses it (an engine-only form, such
+ * as `new X()`, has no oracle). It must also be deterministically executable in
+ * jsdom: triggered by a dispatchable event, free of network / timer /
+ * navigation constructs. Every exclusion is recorded with a reason — the skip
+ * list is part of the result, never silent (`no silent caps`).
  *
  * ## Execution model
  * Per handler and engine: a FRESH jsdom of the whole page, every eligible
@@ -35,15 +38,6 @@
  * before/after snapshot around it. See runHandlerOnEngine for why isolation is
  * worth its cost.
  *
- * ## The engine lane
- * `@hyperfixi/engine` is meant to replace core's engine, so the same sweep
- * runs it against the same oracle: every handler upstream accepts (whether or
- * not core compiles it clean) is executed on upstream and on the engine, and
- * the two effect signatures are compared (`engineCompared`). The parse-level
- * list of what the engine rejects (shipped-sources-engine.test.ts) cannot see
- * a handler that parses on both and runs differently; this can. A handler
- * upstream accepts and the engine rejects is compared too, and diverges.
- *
  * ## Node-only
  * Imports the real `hyperscript.org` build off disk and swaps jsdom globals
  * per handler execution (both engines resolve `document` lazily through
@@ -135,12 +129,12 @@ export interface SkippedHandler extends ShippedHandler {
   reason: string;
 }
 
-/** One compared handler: both engines ran it; signatures either match or not. */
-export interface ComparedHandler extends ShippedHandler {
+/** One handler run on upstream and on `@hyperfixi/engine`; signatures either match or not. */
+export interface EngineComparedHandler extends ShippedHandler {
   /** Stable key: file + source hash + event. Fixing a source changes its key. */
   key: string;
   event: string;
-  hyperfixiEffects: string[];
+  engineEffects: string[];
   upstreamEffects: string[];
   match: boolean;
   /**
@@ -153,25 +147,11 @@ export interface ComparedHandler extends ShippedHandler {
   excerpt: string;
 }
 
-/** One handler run on upstream and on `@hyperfixi/engine`. */
-export interface EngineComparedHandler extends ShippedHandler {
-  key: string;
-  event: string;
-  engineEffects: string[];
-  upstreamEffects: string[];
-  match: boolean;
-  /** Both signatures empty: not evidence of parity (see ComparedHandler.vacuous). */
-  vacuous: boolean;
-  excerpt: string;
-}
-
 export interface ExecutionParityResult {
   /** Pages walked. */
   pages: number;
   /** Handlers found (before eligibility). */
   handlers: number;
-  /** Handlers executed on both engines. */
-  compared: ComparedHandler[];
   /** Handlers excluded, each with its reason. */
   skipped: SkippedHandler[];
   /** Handlers upstream accepts, executed on upstream and on `@hyperfixi/engine`. */
@@ -234,12 +214,8 @@ export function extractHandlers(file: string, html: string): ShippedHandler[] {
 
 /** Minimal engine surfaces, injected by `initEngines`. */
 export interface Engines {
-  /** hyperfixi compile check (fair-denominator side 1). */
-  compileClean(source: string): boolean;
-  /** upstream parse check (fair-denominator side 2). Returns error strings; [] = valid. */
+  /** upstream parse check (the fair denominator). Returns error strings; [] = valid. */
   upstreamErrors(source: string): string[];
-  /** Install a handler on an element via hyperfixi (the public eval surface). */
-  hyperfixiInstall(source: string, el: Element): Promise<void>;
   /** Install a handler on an element via the upstream engine. */
   upstreamInstall(el: Element): void;
   /** `@hyperfixi/engine`'s parse errors for a source; [] = it parses. */
@@ -315,22 +291,6 @@ export async function initEngines(): Promise<Engines> {
   installRejectionTrap();
   installGlobals(new JSDOM('<!doctype html><html><body></body></html>'));
 
-  // Install goes through parse + a FRESH Runtime per handler with the element
-  // as context — the same shape the browser attribute processor uses, and the
-  // same shape the R2 validator proved stable across per-page document swaps.
-  // (The api singleton `hyperscript.eval` binds document-dependent state at
-  // first use, which is correct in a browser — document identity never changes
-  // within a realm — but silently resolves later PAGES' selectors against the
-  // first page here. Measured: a two-page probe no-opped page 2's toggle.)
-  const core = (await import('@hyperfixi/core')) as unknown as {
-    hyperscript: {
-      compileSync(code: string): { ok: boolean; errors?: Array<{ message: string }> };
-    };
-    parse(code: string): { success: boolean; node?: unknown };
-    Runtime: new () => { execute(ast: unknown, ctx: unknown): Promise<unknown> };
-    createContext(el: HTMLElement): unknown;
-  };
-
   const require = createRequire(import.meta.url);
   const esm = path.join(path.dirname(require.resolve('hyperscript.org')), '_hyperscript.esm.js');
   const hs = (await import(pathToFileURL(esm).href)).default as {
@@ -352,14 +312,6 @@ export async function initEngines(): Promise<Engines> {
     engineInstall(el) {
       engine.api.processNode(el);
     },
-    compileClean(source) {
-      try {
-        const r = core.hyperscript.compileSync(source);
-        return r.ok && (r.errors ?? []).length === 0;
-      } catch {
-        return false;
-      }
-    },
     upstreamErrors(source) {
       try {
         return (hs.parse(source)?.errors ?? []).map(e => e.message);
@@ -367,14 +319,6 @@ export async function initEngines(): Promise<Engines> {
         return ['threw: ' + (e as Error).message.split('\n')[0]];
       }
     },
-    async hyperfixiInstall(source, el) {
-      const parsed = core.parse(source);
-      if (!parsed.success || !parsed.node) {
-        throw new Error('parse failed at install (eligibility should have caught this)');
-      }
-      const runtime = new core.Runtime();
-      await runtime.execute(parsed.node, core.createContext(el as HTMLElement));
-    },
     upstreamInstall(el) {
       hs.processNode(el);
     },
@@ -452,7 +396,7 @@ async function runHandlerOnEngine(
 /**
  * The sweep: walk the git-tracked `examples/**` corpus, extract handlers,
  * apply the fair-denominator filters (each skip reasoned), and execute every
- * eligible handler on both engines.
+ * eligible handler on upstream and on the engine.
  */
 export async function runShippedExamplesExecution(opts?: {
   roots?: string[];
@@ -463,7 +407,6 @@ export async function runShippedExamplesExecution(opts?: {
   const roots = opts?.roots ?? DEFAULT_ROOTS;
   const engines = opts?.engines ?? (await initEngines());
 
-  const compared: ComparedHandler[] = [];
   const skipped: SkippedHandler[] = [];
   const engineCompared: EngineComparedHandler[] = [];
   let pages = 0;
@@ -478,9 +421,7 @@ export async function runShippedExamplesExecution(opts?: {
       pages++;
       handlers += pageHandlers.length;
 
-      const eligible: Array<ShippedHandler & { event: string }> = [];
-      // The engine lane's denominator: dispatchable, deterministic, and upstream
-      // accepts it. Core's verdict is not part of it.
+      // The denominator: dispatchable, deterministic, and upstream accepts it.
       const oracle: Array<ShippedHandler & { event: string }> = [];
       for (const h of pageHandlers) {
         if (!h.event) {
@@ -497,26 +438,13 @@ export async function runShippedExamplesExecution(opts?: {
           continue;
         }
         const upstreamErrs = engines.upstreamErrors(h.source);
-        if (upstreamErrs.length === 0) oracle.push(h as ShippedHandler & { event: string });
-        if (!engines.compileClean(h.source)) {
-          skipped.push({
-            ...h,
-            reason: 'hyperfixi does not compile it clean (shipped-sources gate territory)',
-          });
-          continue;
-        }
         if (upstreamErrs.length > 0) {
           skipped.push({ ...h, reason: `upstream rejects it (no oracle): ${upstreamErrs[0]}` });
           continue;
         }
-        eligible.push(h as ShippedHandler & { event: string });
+        oracle.push(h as ShippedHandler & { event: string });
       }
-      if (eligible.length === 0 && oracle.length === 0) continue;
-      // Upstream's signatures from the core lane serve the engine lane too when
-      // the two lanes install the same handlers on the page.
-      const sameHandlers =
-        eligible.length === oracle.length && eligible.every((h, i) => h === oracle[i]);
-      const upstreamRun = new Map<ShippedHandler, string[]>();
+      if (oracle.length === 0) continue;
 
       // Both engines log runtime errors to the console during dispatch
       // (COMMAND FAILED etc.). That is expected data here — the effect
@@ -531,29 +459,11 @@ export async function runShippedExamplesExecution(opts?: {
       const noop = () => {};
       console.log = console.warn = console.error = console.debug = noop;
       try {
-        for (const h of eligible) {
-          const ours = await runHandlerOnEngine(html, eligible, h, (hh, el) =>
-            engines.hyperfixiInstall(hh.source, el)
-          );
-          const theirs = await runHandlerOnEngine(html, eligible, h, (_hh, el) =>
-            engines.upstreamInstall(el)
-          );
-          upstreamRun.set(h, theirs);
-          compared.push({
-            ...h,
-            key: keyFor(h),
-            hyperfixiEffects: ours,
-            upstreamEffects: theirs,
-            match: JSON.stringify(ours) === JSON.stringify(theirs),
-            vacuous: ours.length === 0 && theirs.length === 0,
-            excerpt: h.source.replace(/\s+/g, ' ').trim().slice(0, 100),
-          });
-        }
         for (const h of oracle) {
           const rejected = engines.engineErrors(h.source)[0];
-          const theirs =
-            (sameHandlers && upstreamRun.get(h)) ||
-            (await runHandlerOnEngine(html, oracle, h, (_hh, el) => engines.upstreamInstall(el)));
+          const theirs = await runHandlerOnEngine(html, oracle, h, (_hh, el) =>
+            engines.upstreamInstall(el)
+          );
           const ours =
             rejected !== undefined
               ? [`<engine rejects the source: ${rejected}>`]
@@ -577,5 +487,5 @@ export async function runShippedExamplesExecution(opts?: {
     }
   }
 
-  return { pages, handlers, compared, skipped, engineCompared };
+  return { pages, handlers, skipped, engineCompared };
 }

package/src/multilingual/shipped-sources-engine.test.ts

@@ -1,21 +1,24 @@
 /**
- * Shipped sources on `@hyperfixi/engine`: what replacing core's engine would break.
+ * Shipped sources on `@hyperfixi/engine`: every English source must parse.
  *
- * `packages/engine` is meant to replace the engine in `packages/core`. Every
- * hyperscript source this repository ships (`examples/` and the doc trees, the
- * validity gate's collection) that core compiles clean is put to the engine's
- * parser. The ones it rejects are listed in
+ * Every hyperscript source this repository ships in English (`examples/` and
+ * the doc trees; a source under a non-English `lang` is the localized gate's)
+ * is put to the engine's parser. The ones it rejects are listed in
  * `baselines/shipped-sources-engine.json`, each with the reason it is still
  * there. Three assertions, as the sibling gates:
  *   1. sanity: sources were found and the engine reads most of them;
  *   2. no NEW rejected source outside the list. A page or a doc example
- *      written in syntax only core has would break when core's engine goes;
- *      write upstream's spelling (`packages/engine/README.md` lists the forms
- *      that were considered and not kept), or list it with a reason;
+ *      written in syntax the engine lacks (core 3.x's own forms among it)
+ *      does not run; write upstream's spelling (`packages/engine/README.md`
+ *      lists the forms that were considered and not kept), or list it with a
+ *      reason;
  *   3. no stale entry: a listed source the engine now reads, or one that was
  *      edited (the key embeds a hash of the source), must be removed, so the
- *      list only shrinks. It is empty when core's engine can be replaced
- *      without breaking a shipped page.
+ *      list only shrinks. It has been empty since the history pages moved to
+ *      `call history.pushState` (Phase B1).
+ *
+ * Until Phase C4 the denominator was the sources `@hyperfixi/core` compiled
+ * clean (see `checkShippedSourcesOnEngine`).
  *
  * This is a PARSE-level gate. A source can parse on both engines and run
  * differently; the engine lane of `shipped-examples-execution.test.ts` is the
@@ -32,7 +35,6 @@ import { JSDOM } from 'jsdom';
 import { describe, it, expect, beforeAll } from 'vitest';
 import {
   checkShippedSourcesOnEngine,
-  type CompileForValidity,
   type ShippedSourcesOnEngineResult,
 } from './shipped-sources-validity';
 
@@ -51,14 +53,10 @@ describe('shipped sources on @hyperfixi/engine', () => {
   let result: ShippedSourcesOnEngineResult;
 
   beforeAll(async () => {
-    const core = (await import('@hyperfixi/core')) as unknown as {
-      hyperscript: { compileSync: CompileForValidity };
-    };
     const { api, everything, register } = await import('@hyperfixi/engine');
     register(...everything);
     const dom = new JSDOM('<!doctype html><html><body></body></html>');
     result = checkShippedSourcesOnEngine(
-      code => core.hyperscript.compileSync(code),
       code => {
         try {
           return api.parse(code).errors.map(error => error.message);
@@ -66,13 +64,15 @@ describe('shipped sources on @hyperfixi/engine', () => {
           return ['threw: ' + (e instanceof Error ? e.message : String(e))];
         }
       },
-      dom.window.document as unknown as Parameters<typeof checkShippedSourcesOnEngine>[2]
+      dom.window.document as unknown as Parameters<typeof checkShippedSourcesOnEngine>[1]
     );
   }, 120_000);
 
   it('finds the shipped sources and the engine reads most of them (sanity)', () => {
-    expect(result.coreClean).toBeGreaterThan(200);
-    expect(result.engineAccepts).toBeGreaterThan(200);
+    expect(result.checked).toBeGreaterThan(300);
+    expect(result.engineAccepts).toBeGreaterThan(300);
+    // Written in another language: the localized gate's, not this one's.
+    expect(result.localized).toBeGreaterThan(10);
   });
 
   it('has no NEW shipped source the engine rejects outside the list', () => {
@@ -80,7 +80,7 @@ describe('shipped sources on @hyperfixi/engine', () => {
     expect(
       unexpected,
       unexpected.length
-        ? `\nShipped sources core compiles and @hyperfixi/engine rejects (write upstream's spelling,\n` +
+        ? `\nShipped sources @hyperfixi/engine rejects (write upstream's spelling,\n` +
             `or list it in baselines/shipped-sources-engine.json with a reason):\n` +
             unexpected
               .map(r => `  [${r.key}]\n      "${r.excerpt}"\n      -> ${r.error}`)

package/src/multilingual/shipped-sources-localized.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Shipped sources written in another language, through the multilingual path.
+ *
+ * Both shipped-sources gates hand every `_` to an English parser, which
+ * rejects a script written in Spanish, so they skip it — and nothing else
+ * looked. On a page such a script runs through `@lokascript/hyperscript-
+ * adapter`, which translates it under its element's `lang`. This gate does
+ * the same and requires English that upstream `_hyperscript` and
+ * `@hyperfixi/engine` both parse (Phase C2c; fifteen attributes today: the
+ * `live` blocks of examples/hx-v4-i18n/live-multilang.html, the example in
+ * docs/BROWSER_BUNDLES.md's "Hyperscript in another language", and the
+ * multilingual section of packages/core/docs/EXAMPLES.md).
+ *
+ * @vitest-environment node
+ * Required: the hosts and the collector need real jsdom documents.
+ */
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { describe, it, expect, beforeAll } from 'vitest';
+import { JSDOM } from 'jsdom';
+import { preprocess } from '@lokascript/hyperscript-adapter';
+import { collectLocalizedSources, type LocalizedSource } from './shipped-sources-validity';
+import { installGlobals } from './shipped-examples-execution';
+
+interface ParseHost {
+  parse(source: string): { errors?: Array<{ message: string }> } | undefined;
+}
+
+describe('shipped sources written in another language', () => {
+  const sources: LocalizedSource[] = collectLocalizedSources();
+  let upstream: ParseHost;
+  let engine: ParseHost;
+
+  beforeAll(async () => {
+    installGlobals(new JSDOM('<!doctype html><html><body></body></html>'));
+    const require = createRequire(import.meta.url);
+    const esm = require.resolve('hyperscript.org').replace(/[^/\\]+$/, '_hyperscript.esm.js');
+    upstream = (await import(pathToFileURL(esm).href)).default as ParseHost;
+    const engineModule = await import('@hyperfixi/engine');
+    engineModule.register(...engineModule.everything);
+    engine = engineModule.api;
+  });
+
+  it('finds them (a page that moves them changes this count on purpose)', () => {
+    expect(sources.map(s => `${s.file} [${s.lang}]`)).toEqual([
+      'examples/hx-v4-i18n/live-multilang.html [es]',
+      'examples/hx-v4-i18n/live-multilang.html [ja]',
+      'examples/hx-v4-i18n/live-multilang.html [ar]',
+      // The engine + adapter example in "Hyperscript in another language" (C-R3).
+      'docs/BROWSER_BUNDLES.md [ja]',
+      // "Multilingual Examples". Marked with `lang` in C4b: core's English parser had
+      // kept them out of the engine gate; the engine gate now reads everything else.
+      'packages/core/docs/EXAMPLES.md [es]',
+      'packages/core/docs/EXAMPLES.md [ja]',
+      'packages/core/docs/EXAMPLES.md [ar]',
+      'packages/core/docs/EXAMPLES.md [es]',
+      'packages/core/docs/EXAMPLES.md [ja]',
+      'packages/core/docs/EXAMPLES.md [ko]',
+      'packages/core/docs/EXAMPLES.md [es]',
+      'packages/core/docs/EXAMPLES.md [fr]',
+      'packages/core/docs/EXAMPLES.md [de]',
+      'packages/core/docs/EXAMPLES.md [es]',
+      'packages/core/docs/EXAMPLES.md [pt]',
+    ]);
+  });
+
+  it('each translates to English upstream and the engine both parse', () => {
+    const failures: string[] = [];
+    for (const s of sources) {
+      let english: string;
+      try {
+        english = preprocess(s.source, s.lang);
+      } catch (e) {
+        failures.push(`${s.file} [${s.lang}] threw: ${(e as Error).message}`);
+        continue;
+      }
+      const first = (host: ParseHost) => host.parse(english)?.errors?.[0]?.message.split('\n')[0];
+      const problem =
+        english === s.source
+          ? 'not translated'
+          : (first(upstream) && `upstream: ${first(upstream)}`) ||
+            (first(engine) && `engine: ${first(engine)}`);
+      if (problem) failures.push(`${s.file} [${s.lang}] ${problem}\n  ${s.source}\n  → ${english}`);
+    }
+    expect(failures).toEqual([]);
+  });
+});