@hyperfixi/testing-framework 3.2.0 → 4.0.0

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

@@ -3,20 +3,26 @@
  * 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).
  *
+ * (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
  * source hash, so FIXING a handler changes its key and assertion 3 forces the
@@ -31,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';
@@ -47,7 +53,8 @@ import {
 } from './shipped-examples-execution';
 
 interface AllowlistDoc {
-  allowedDivergences: Array<{
+  /** `@hyperfixi/engine` against upstream. */
+  allowedEngineDivergences: Array<{
     key: string;
     file: string;
     event: string;
@@ -61,9 +68,9 @@ 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));
 
-describe('shipped-examples execution gate', () => {
+describe('shipped-examples execution gate: @hyperfixi/engine against upstream', () => {
   let result: ExecutionParityResult;
 
   beforeAll(async () => {
@@ -76,10 +83,11 @@ 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}`);
@@ -87,9 +95,9 @@ describe('shipped-examples execution gate', () => {
   }, 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
@@ -97,46 +105,49 @@ 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);
+    const realMatches = result.engineCompared.filter(c => c.match && !c.vacuous).length;
+    expect(realMatches).toBeGreaterThan(60);
   });
 
   it('has no NEW divergence from upstream outside the allowlist', () => {
-    const unexpected = result.compared.filter(c => !c.match && !allowed.has(c.key));
+    const unexpected = result.engineCompared.filter(c => !c.match && !allowedOnEngine.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` +
+        ? `\nShipped handlers whose DOM effect on @hyperfixi/engine DIVERGES from the hyperscript.org ` +
+            `engine\n(the engine follows upstream's source: fix the engine, or allowlist with a reason ` +
+            `under allowedEngineDivergences):\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)}`
+                  `      engine  : ${JSON.stringify(f.engineEffects).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.`
+            `\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 (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));
+    const stillDiverging = new Set(result.engineCompared.filter(c => !c.match).map(c => c.key));
+    const stale = allowlist.allowedEngineDivergences
+      .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` +
+        ? `\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 baselines/shipped-examples-execution.json:\n  ${stale.join('\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
@@ -126,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;
   /**
@@ -149,10 +152,10 @@ export interface ExecutionParityResult {
   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`. */
+  engineCompared: EngineComparedHandler[];
 }
 
 /** Stable key for one handler execution. */
@@ -211,14 +214,14 @@ 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. */
+  engineErrors(source: string): string[];
+  /** Install a handler on an element via `@hyperfixi/engine`. */
+  engineInstall(el: Element): void;
 }
 
 /**
@@ -288,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 {
@@ -311,15 +298,20 @@ export async function initEngines(): Promise<Engines> {
     processNode(el: Node): void;
   };
 
+  const engine = await import('@hyperfixi/engine');
+  engine.register(...engine.everything);
+
   return {
-    compileClean(source) {
+    engineErrors(source) {
       try {
-        const r = core.hyperscript.compileSync(source);
-        return r.ok && (r.errors ?? []).length === 0;
-      } catch {
-        return false;
+        return engine.api.parse(source).errors.map(e => e.message.split('\n')[0] ?? '');
+      } catch (e) {
+        return ['threw: ' + (e as Error).message.split('\n')[0]];
       }
     },
+    engineInstall(el) {
+      engine.api.processNode(el);
+    },
     upstreamErrors(source) {
       try {
         return (hs.parse(source)?.errors ?? []).map(e => e.message);
@@ -327,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);
     },
@@ -412,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[];
@@ -423,8 +407,8 @@ 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;
   let handlers = 0;
 
@@ -437,7 +421,8 @@ export async function runShippedExamplesExecution(opts?: {
       pages++;
       handlers += pageHandlers.length;
 
-      const eligible: Array<ShippedHandler & { event: string }> = [];
+      // The denominator: dispatchable, deterministic, and upstream accepts it.
+      const oracle: Array<ShippedHandler & { event: string }> = [];
       for (const h of pageHandlers) {
         if (!h.event) {
           skipped.push({ ...h, reason: 'not an `on <event>` handler' });
@@ -452,21 +437,14 @@ export async function runShippedExamplesExecution(opts?: {
           skipped.push({ ...h, reason: disq.reason });
           continue;
         }
-        if (!engines.compileClean(h.source)) {
-          skipped.push({
-            ...h,
-            reason: 'hyperfixi does not compile it clean (shipped-sources gate territory)',
-          });
-          continue;
-        }
         const upstreamErrs = engines.upstreamErrors(h.source);
         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) continue;
+      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
@@ -481,17 +459,19 @@ 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) =>
+        for (const h of oracle) {
+          const rejected = engines.engineErrors(h.source)[0];
+          const theirs = await runHandlerOnEngine(html, oracle, h, (_hh, el) =>
             engines.upstreamInstall(el)
           );
-          compared.push({
+          const ours =
+            rejected !== undefined
+              ? [`<engine rejects the source: ${rejected}>`]
+              : await runHandlerOnEngine(html, oracle, h, (_hh, el) => engines.engineInstall(el));
+          engineCompared.push({
             ...h,
             key: keyFor(h),
-            hyperfixiEffects: ours,
+            engineEffects: ours,
             upstreamEffects: theirs,
             match: JSON.stringify(ours) === JSON.stringify(theirs),
             vacuous: ours.length === 0 && theirs.length === 0,
@@ -507,5 +487,5 @@ export async function runShippedExamplesExecution(opts?: {
     }
   }
 
-  return { pages, handlers, compared, skipped };
+  return { pages, handlers, skipped, engineCompared };
 }

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

@@ -0,0 +1,106 @@
+/**
+ * Shipped sources on `@hyperfixi/engine`: every English source must parse.
+ *
+ * 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 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 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
+ * gate for that.
+ *
+ * To see the list by form, and beside upstream's verdict:
+ * `npx tsx packages/engine/tools/shipped-sources.mts`.
+ */
+
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { JSDOM } from 'jsdom';
+import { describe, it, expect, beforeAll } from 'vitest';
+import {
+  checkShippedSourcesOnEngine,
+  type ShippedSourcesOnEngineResult,
+} from './shipped-sources-validity';
+
+interface RejectedDoc {
+  rejected: Array<{ key: string; file: string; error: string; excerpt: string; reason: string }>;
+}
+
+const baselinePath = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  '../../baselines/shipped-sources-engine.json'
+);
+const listed = JSON.parse(readFileSync(baselinePath, 'utf8')) as RejectedDoc;
+const allowed = new Set(listed.rejected.map(e => e.key));
+
+describe('shipped sources on @hyperfixi/engine', () => {
+  let result: ShippedSourcesOnEngineResult;
+
+  beforeAll(async () => {
+    const { api, everything, register } = await import('@hyperfixi/engine');
+    register(...everything);
+    const dom = new JSDOM('<!doctype html><html><body></body></html>');
+    result = checkShippedSourcesOnEngine(
+      code => {
+        try {
+          return api.parse(code).errors.map(error => error.message);
+        } catch (e) {
+          return ['threw: ' + (e instanceof Error ? e.message : String(e))];
+        }
+      },
+      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.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', () => {
+    const unexpected = result.rejections.filter(r => !allowed.has(r.key));
+    expect(
+      unexpected,
+      unexpected.length
+        ? `\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}`)
+              .join('\n') +
+            `\n\nOne source on the engine and on upstream, side by side:\n` +
+            `  npx tsx packages/engine/tools/probe.mts '<source>'`
+        : ''
+    ).toEqual([]);
+  });
+
+  it('has no stale entries (a source the engine now reads must be removed, so the list only shrinks)', () => {
+    const stillRejected = new Set(result.rejections.map(r => r.key));
+    const stale = listed.rejected.map(e => e.key).filter(key => !stillRejected.has(key));
+    expect(
+      stale,
+      stale.length
+        ? `\nThese listed sources are no longer rejected (read by the engine now, or edited: the key\n` +
+            `embeds a hash of the source). Remove them from baselines/shipped-sources-engine.json:\n  ` +
+            stale.join('\n  ')
+        : ''
+    ).toEqual([]);
+  });
+});

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([]);
+  });
+});