xbintsc 0.3.3 → 0.3.5

package/dist/tests/e2e/differential.test.js

@@ -0,0 +1,581 @@
+/**
+ * Differential tests: compile a program with xbintsc, run it, and compare the
+ * output byte-for-byte with the same program executed by Node. Every program
+ * prints canonical `JSON.stringify` lines so console formatting never masks a
+ * real semantic difference.
+ */
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("differential vs Node", (harness) => {
+    /** Register one differential case from a complete program source. */
+    const diff = (name, source) => {
+        it(name, () => {
+            harness.expectSameOutputAsNode(source, { name: `diff_${name.replace(/\W+/g, "_")}` });
+        });
+    };
+    const printAll = (values) => `const values: unknown[] = [\n${values.map((v) => `  ${v},`).join("\n")}\n];\n` +
+        `for (const v of values) console.log(JSON.stringify(v));\n`;
+    diff("number formatting and coercion", printAll([
+        "0",
+        "-0",
+        "1.5",
+        "0.1",
+        "1 / 3",
+        "1e21",
+        "1e-7",
+        "1e-6",
+        "123456789012345680000",
+        "Number.MAX_SAFE_INTEGER",
+        "Number.MIN_SAFE_INTEGER",
+        "Number.EPSILON",
+        "Infinity",
+        "-Infinity",
+        "NaN",
+        "(1234.5678).toFixed(2)",
+        "(0.000001).toFixed(7)",
+        "(1e21).toFixed(2)",
+        "(2.5).toFixed(0)",
+        "(-2.5).toFixed(0)",
+        "(123.456).toPrecision(5)",
+        "(123.4).toPrecision(10)",
+        "(0.0001234).toPrecision(2)",
+        "(12345).toExponential()",
+        "(12345).toExponential(2)",
+        "(0.000123).toExponential(3)",
+        "(255).toString(16)",
+        "(255).toString(2)",
+        "String(42)",
+        "String(1e21)",
+        "String(1e-7)",
+    ]));
+    diff("number parsing and predicates", printAll([
+        'Number("  42  ")',
+        'Number("")',
+        'Number("0x1f")',
+        'Number("0b101")',
+        'Number("0o17")',
+        'Number("abc")',
+        'parseInt("42px")',
+        'parseFloat("3.14abc")',
+        "isNaN(NaN)",
+        "isFinite(3)",
+        "Number.isInteger(3)",
+        "Number.isInteger(3.5)",
+        "Number.isNaN(NaN)",
+        "Number.isFinite(Infinity)",
+        "Number.isSafeInteger(2 ** 53)",
+    ]));
+    diff("abstract equality and coercion", printAll([
+        '1 == "1"',
+        '1 === "1"',
+        "0 == false",
+        '"" == false',
+        "null == undefined",
+        "null === undefined",
+        "[] == false",
+        "[] == 0",
+        "[1] == 1",
+        '[1, 2] == "1,2"',
+        '{} == "[object Object]"',
+        "NaN == NaN",
+        '"1" == true',
+        '"0" == false',
+    ]));
+    diff("arithmetic and relational operators", printAll([
+        "[] + []",
+        "[1] + [2]",
+        "[1, 2] + [3]",
+        '{} + ""',
+        '1 + "2"',
+        '"3" - 1',
+        '"3" * "2"',
+        "true + 1",
+        "null + 1",
+        "undefined + 1",
+        '+ "42"',
+        '+ "0x1f"',
+        '+ ""',
+        '+ "  12  "',
+        '+ "abc"',
+        "[2] < 3",
+        '[1, 2] < "1,3"',
+        '"10" < "9"',
+        "10 < 9",
+        "2 ** 10",
+        "7 % 3",
+        "-7 % 3",
+        "1 / 0",
+        "0 / 0",
+    ]));
+    diff("logical operators, bitwise and typeof", printAll([
+        '0 || "x"',
+        '"" || "y"',
+        'null ?? "z"',
+        'undefined ?? "w"',
+        "0 ?? 5",
+        "5 & 3",
+        "5 | 2",
+        "5 ^ 1",
+        "~5",
+        "1 << 4",
+        "-8 >> 1",
+        "-8 >>> 1",
+        "typeof 1",
+        'typeof "a"',
+        "typeof true",
+        "typeof undefined",
+        "typeof null",
+        "typeof {}",
+        "typeof []",
+        "typeof (() => 1)",
+    ]));
+    diff("string methods", printAll([
+        '"Hello, World".length',
+        '"Hello, World".toUpperCase()',
+        '"Hello, World".toLowerCase()',
+        '"Hello, World".indexOf("o")',
+        '"Hello, World".lastIndexOf("o")',
+        '"Hello, World".includes("World")',
+        '"Hello, World".slice(7)',
+        '"Hello, World".slice(-5)',
+        '"Hello, World".substring(0, 5)',
+        '"Hello, World".substr(7, 3)',
+        '"a, b, c".split(", ")',
+        '"Hello".replace("l", "L")',
+        '"Hello".replaceAll("l", "L")',
+        '"ab".repeat(3)',
+        '"Hello".charAt(1)',
+        '"Hello".charCodeAt(0)',
+        '"  pad  ".trim()',
+        '"ab".padStart(5, "-")',
+        '"ab".padEnd(5, "-")',
+        '"Hello".concat("!" )',
+        '"a1b2c3".match(/\\d/g)',
+        '"a1b2c3".replace(/\\d/g, "#")',
+        '"abc".at(-1)',
+        '"Hello".localeCompare("World")',
+    ]));
+    diff("array methods", printAll([
+        "[3, 1, 2].sort()",
+        '["banana", "apple", "cherry"].sort()',
+        "[10, 9, 100].sort()",
+        "[3, 1, 2].sort((a, b) => a - b)",
+        "[1, 2, 3].map((x) => x * 2)",
+        "[1, 2, 3, 4].filter((x) => x % 2 === 0)",
+        "[1, 2, 3].reduce((a, b) => a + b, 0)",
+        "[1, 2, 3].reverse()",
+        '[1, 2, 3].join("-")',
+        "[1, [2, [3, [4]]]].flat(2)",
+        "[1, 2, 3].flatMap((x) => [x, x])",
+        "[1, 2, 3, 4].slice(1, 3)",
+        "[1, 2, 3].concat([4, 5])",
+        "[1, 2, 3].indexOf(2)",
+        "[1, 2, 3].includes(4)",
+        "[5, 3, 8].find((x) => x > 4)",
+        "[1, 2, 3].some((x) => x > 2)",
+        "[1, 2, 3].every((x) => x > 0)",
+        "Array.isArray([])",
+        "Array.from([1, 2, 3], (x) => x + 1)",
+        "Array.of(1, 2, 3)",
+        "[1, 2, 3].fill(0, 1)",
+        "[1, 2, 3, 4].copyWithin(0, 2)",
+        "[1, 2, 3].at(-1)",
+        "[1, 2, 3].splice(1, 1)",
+    ]));
+    diff("objects, key order and JSON", `const o = { b: 2, a: 1, "10": "ten", "2": "two", c: 3 };
+${printAll([
+        "Object.keys(o)",
+        "Object.values(o)",
+        "Object.entries(o)",
+        "JSON.stringify(o)",
+        "JSON.stringify({ x: undefined, y: null, z: () => 1 })",
+        "JSON.stringify([undefined, null, () => 1])",
+        "JSON.stringify({ a: { b: [1, 2, { c: 3 }] } })",
+        'JSON.stringify("hi")',
+        "JSON.stringify(5)",
+        "JSON.stringify(true)",
+        "JSON.stringify(null)",
+        "JSON.stringify(NaN)",
+        "JSON.stringify(Infinity)",
+        "JSON.stringify(undefined)",
+        "Object.assign({}, o, { d: 4 })",
+        "{ ...o, e: 5 }",
+        '"a" in o',
+        'o.hasOwnProperty("a")',
+    ])}`);
+    diff("control flow, closures and classes", `function fib(n: number): number { return n < 2 ? n : fib(n - 1) + fib(n - 2); }
+function classify(x: number): string {
+  if (x < 0) return "neg";
+  else if (x === 0) return "zero";
+  return "pos";
+}
+function sum(...xs: number[]): number { return xs.reduce((a, b) => a + b, 0); }
+function defaults(a: number, b = 10, c = a + b): number { return a + b + c; }
+function safeDiv(a: number, b: number): string {
+  try {
+    if (b === 0) throw new Error("divide by zero");
+    return String(a / b);
+  } catch (err) {
+    return "caught";
+  } finally {
+    // always runs
+  }
+}
+class Animal {
+  name: string;
+  constructor(name: string) { this.name = name; }
+  speak(): string { return this.name + " makes a sound"; }
+  static create(n: string): Animal { return new Animal(n); }
+}
+class Dog extends Animal {
+  constructor(name: string) { super(name); }
+  speak(): string { return this.name + " barks"; }
+}
+const counter = () => { let c = 0; return () => ++c; };
+const mk = counter();
+const results: unknown[] = [
+  fib(10), classify(-5), classify(0), classify(5), sum(1, 2, 3),
+  defaults(1), defaults(1, 2), defaults(1, 2, 3),
+  mk(), mk(), mk(),
+  new Animal("Cat").speak(), new Dog("Rex").speak(), Animal.create("Bird").speak(),
+  Dog.prototype instanceof Animal,
+  safeDiv(10, 2), safeDiv(1, 0),
+  (() => { let s = 0; for (let i = 0; i < 5; i++) s += i; return s; })(),
+  (() => { let s = ""; for (const ch of ["a", "b", "c"]) s += ch; return s; })(),
+  (() => { let i = 0, s = 0; while (i < 3) { s += i; i++; } return s; })(),
+  (() => { let i = 0; do { i++; } while (i < 3); return i; })(),
+  (() => { switch (2) { case 1: return "one"; case 2: return "two"; default: return "other"; } })(),
+];
+for (const v of results) console.log(JSON.stringify(v));`);
+    diff("Math, collections and dates", printAll([
+        "Math.max(1, 2, 3)",
+        "Math.min()",
+        "Math.abs(-3)",
+        "Math.floor(1.9)",
+        "Math.ceil(1.1)",
+        "Math.round(2.5)",
+        "Math.round(-2.5)",
+        "Math.trunc(-1.9)",
+        "Math.sign(-5)",
+        "Math.sqrt(16)",
+        "Math.pow(2, 8)",
+        "Math.PI",
+        "new Date(0).toISOString()",
+        "new Date(1000).getTime()",
+        "new Date(2020, 0, 1).getUTCFullYear()",
+        "new Date(Date.UTC(2020, 5, 15)).toISOString()",
+        "[...new Set([1, 2, 2, 3])]",
+        "[...new Map([[\"a\", 1], [\"b\", 2]]).keys()]",
+    ]));
+    diff("regexp capture groups and string splitting", printAll([
+        '"12-34".match(/(\\d+)-(\\d+)/)',
+        '"a1b2c3".split(/(\\d)/)',
+        '"a1b2c3".split(/\\d/)',
+        '"2020-01-02".replace(/(\\d+)-(\\d+)-(\\d+)/, "$3/$2/$1")',
+        '"a1b2".replace(/(\\d)/g, "[$1]")',
+        '"a.b.c".search(/\\./)',
+        '"abc".split(/(?:)/)',
+        '"hello world".match(/(\\w+) (\\w+)/)',
+        '"aaa".split("a", 2)',
+        '"a,b;c".split(/[,;]/)',
+    ]));
+    diff("immutable array methods and Object statics", printAll([
+        "[3, 1, 2].toSorted((x, y) => x - y)",
+        "[3, 1, 2].toReversed()",
+        "[3, 1, 2].toSpliced(1, 1, 9, 9)",
+        "[3, 1, 2].with(1, 9)",
+        "[3, 1, 2].with(-1, 9)",
+        "Object.getOwnPropertyNames({ b: 1, a: 2 })",
+        "Object.getOwnPropertyNames([1, 2])",
+        "Object.groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? \"even\" : \"odd\"))",
+        "Array.from({ length: 3 }, (_v, i) => i * 2)",
+    ]));
+    diff("tagged templates and String.raw", `function tag(strings: TemplateStringsArray, ...values: unknown[]): string {
+  let out = strings[0];
+  for (let i = 0; i < values.length; i++) out += "[" + String(values[i]) + "]" + strings[i + 1];
+  return out;
+}
+const obj = {
+  prefix: "<",
+  tag(strings: TemplateStringsArray, ...values: unknown[]): string {
+    return this.prefix + strings.join("|") + "/" + JSON.stringify(strings.raw) + "/" + values.join(",");
+  },
+};
+const name = "world";
+${printAll([
+        'tag`hello ${name} and ${1 + 1}!`',
+        'tag`no substitutions`',
+        'obj.tag`a\\n${name}b${2}`',
+        'String.raw`a\\nb\\t${name}c`',
+        'String.raw`plain`',
+        'tag`${name}`',
+    ])}`);
+    diff("Function.prototype.call, apply and bind", `function add(a: number, b: number): number { return a + b; }
+const obj = {
+  base: 10,
+  sum(a: number, b: number): number { return this.base + a + b; },
+};
+class Greeter {
+  prefix = "hi";
+  greet(name: string): string { return this.prefix + " " + name; }
+}
+const g = new Greeter();
+const bound = obj.sum.bind(obj, 1);
+const bound2 = add.bind(null, 10);
+const mk = (x: number) => x * 2;
+${printAll([
+        "add.call(null, 1, 2)",
+        "obj.sum.call(obj, 1, 2)",
+        "obj.sum.apply(obj, [3, 4])",
+        "add.apply(null, [5, 6])",
+        "bound(2)",
+        "bound2(5)",
+        'g.greet.call(g, "ada")',
+        'g.greet.apply(g, ["bob"])',
+        'g.greet.bind(g)("cy")',
+        "mk.call(null, 21)",
+        "mk.apply(null, [3])",
+    ])}`);
+    diff("first-class built-in method values", `const array = [1, 2, 3];
+const text = "abc";
+const fn = function (x: number): number { return x; };
+const date = new Date(0);
+const map = new Map<string, number>();
+map.set("a", 1);
+const set = new Set<number>([1, 2]);
+const regexp = /a(b)c/;
+const object = { base: 10, add(n: number): number { return this.base + n; } };
+type Holder = { base: number; go?: (n: number) => number };
+const holder: Holder = { base: 10, go(n: number): number { return this.base + n; } };
+const empty: { go?: (n: number) => number } = {};
+const results: unknown[] = [
+  typeof array.map,
+  typeof array.push,
+  typeof text.slice,
+  typeof fn.call,
+  typeof date.getTime,
+  typeof map.get,
+  typeof set.add,
+  typeof regexp.test,
+  array.map.name,
+  array.map.length,
+  text.slice.length,
+  array.map(function (x: number): number { return x * 2; }),
+  array.map?.((x: number): number => x + 1),
+  text.split?.(""),
+  object.add(5),
+  holder.go?.(3),
+  empty.go?.(3),
+];
+for (const value of results) console.log(JSON.stringify(value));
+try {
+  const detached = array.map;
+  (detached as unknown as (cb: (x: number) => number) => number[])((x: number): number => x);
+  console.log(JSON.stringify("no throw"));
+} catch (caught) {
+  console.log(JSON.stringify("threw"));
+}
+`);
+    diff("object-literal getters and setters", `const obj = {
+  _x: 0,
+  get x(): number { return this._x; },
+  set x(v: number) { this._x = v * 2; },
+  get double(): number { return this._x * 2; },
+  method(a: number, b: number): number { return a + b; },
+};
+obj.x = 5;
+const base = 7;
+const o2 = { base, get next() { return base + 1; } };
+const o3 = { get ["dyn" + "amic"]() { return 42; } };
+${printAll([
+        "obj.x",
+        "obj.double",
+        "obj.method(2, 3)",
+        "Object.keys(obj)",
+        "o2.base",
+        "o2.next",
+        "o3.dynamic",
+    ])}`);
+    diff("Error family and AggregateError", `
+const e = new Error("boom");
+class MyErr extends Error {
+  constructor(m: string) { super(m); this.name = "MyErr"; }
+}
+class CustomRange extends RangeError {}
+const m = new MyErr("m");
+const r = new CustomRange("too big");
+const agg = new AggregateError([1, 2], "all failed");
+${printAll([
+        "typeof Error",
+        "typeof TypeError",
+        "typeof AggregateError",
+        "e instanceof Error",
+        "new TypeError('b') instanceof TypeError",
+        "new TypeError('b') instanceof Error",
+        "new RangeError('c') instanceof TypeError",
+        "String(e)",
+        "e.toString()",
+        "e.name",
+        "e.message",
+        "m.name",
+        "m.message",
+        "m instanceof MyErr",
+        "m instanceof Error",
+        "m instanceof TypeError",
+        "r.name",
+        "r.message",
+        "r instanceof RangeError",
+        "r instanceof Error",
+        "agg.name",
+        "agg.message",
+        "agg.errors",
+        "agg instanceof AggregateError",
+        "agg instanceof Error",
+        "String(agg)",
+        "typeof e.stack",
+    ])}`);
+    diff("Promise.any rejects with an AggregateError", `
+Promise.any([Promise.reject("a"), Promise.reject("b"), Promise.resolve(42)])
+  .then((value) => console.log(JSON.stringify(["fulfilled", value])))
+  .catch((reason) => {
+    const err = reason as { name: string; message: string; errors: unknown[] };
+    console.log(JSON.stringify([err.name, err.message, err.errors]));
+  });
+Promise.any([Promise.reject("x"), Promise.reject("y")]).catch((reason) => {
+  const err = reason as { name: string; errors: unknown[] };
+  console.log(JSON.stringify([err.name, err.errors, reason instanceof AggregateError]));
+});
+`);
+    diff("generators", `
+function* nums() { yield 1; yield 2; yield 3; }
+const g = nums();
+console.log(JSON.stringify([typeof nums, g.next(), g.next(), g.next(), g.next()]));
+
+function* counter(start: number) {
+  let x = start;
+  while (true) {
+    const step = yield x;
+    x = step === undefined ? x + 1 : step;
+  }
+}
+const c = counter(10);
+console.log(JSON.stringify([c.next().value, c.next().value, c.next(100).value, c.next().value]));
+
+function* inner() { yield "a"; return "done"; }
+function* outer() { const r = yield* inner(); yield r; yield* [1, 2]; }
+console.log(JSON.stringify([...outer()]));
+
+function* echo() { const a = yield "first"; const b = yield a; return b; }
+const e = echo();
+console.log(JSON.stringify([e.next(), e.next("A"), e.next("B")]));
+
+function* guarded() {
+  try { yield "x"; } catch (err) { yield "caught:" + (err as Error).message; }
+  yield "end";
+}
+const t = guarded();
+console.log(JSON.stringify([t.next(), t.throw(new Error("E")), t.next(), t.next()]));
+
+function* naturals() { let i = 0; while (true) yield i++; }
+const seen: number[] = [];
+for (const v of naturals()) { if (v >= 3) break; seen.push(v); }
+console.log(JSON.stringify(seen));
+
+class Box {
+  private n = 0;
+  *gen(): Generator<number> { yield this.n++; yield this.n++; }
+}
+console.log(JSON.stringify([...new Box().gen()]));
+
+const obj = {
+  base: 5,
+  *gen() { yield this.base; yield this.base * 2; },
+};
+console.log(JSON.stringify([...obj.gen(), Math.max(...obj.gen())]));
+`);
+    it("implements symbols and the well-known symbol protocol", () => {
+        harness.expectSameOutputAsNode(`const a = Symbol("desc");
+const b = Symbol("desc");
+const lines: unknown[] = [
+  typeof Symbol,
+  typeof a,
+  a === a,
+  a === b,
+  a.toString(),
+  String(a),
+  a.description,
+  Symbol().description,
+  String(Symbol()),
+  String(Symbol.iterator),
+  Symbol.iterator === Symbol.iterator,
+  Symbol.for("k") === Symbol.for("k"),
+  Symbol.keyFor(Symbol.for("k")),
+  Symbol.keyFor(Symbol("k")),
+];
+for (const line of lines) console.log(JSON.stringify(line));
+
+const holder: Record<string, unknown> = {};
+(holder as any)[a] = 1;
+(holder as any)[b] = 2;
+holder.x = 3;
+console.log(JSON.stringify(Object.keys(holder)));
+console.log(JSON.stringify(Object.getOwnPropertySymbols(holder).length));
+console.log(
+  JSON.stringify([(holder as any)[a], (holder as any)[b], (holder as any)[Symbol("desc")]]),
+);
+console.log(JSON.stringify(holder));
+console.log(JSON.stringify(a));
+console.log(JSON.stringify([a, 1]));
+
+class Range {
+  start: number;
+  end: number;
+  constructor(start: number, end: number) {
+    this.start = start;
+    this.end = end;
+  }
+  [Symbol.iterator]() {
+    let i = this.start;
+    const end = this.end;
+    return {
+      next() {
+        return i < end ? { value: i++, done: false } : { value: undefined, done: true };
+      },
+    };
+  }
+}
+console.log(JSON.stringify([...new Range(1, 4)]));
+const walked: number[] = [];
+for (const x of new Range(10, 13)) walked.push(x);
+console.log(JSON.stringify(walked));
+
+function* delegates() { yield* new Range(5, 7); }
+console.log(JSON.stringify([...delegates()]));
+`, { name: "diff_symbol" });
+    });
+    it("binds namespace imports to every export", () => {
+        harness.expectSameOutputAsNode(`import * as util from "./util.ts";
+import { add } from "./util.ts";
+const values: unknown[] = [
+  util.greeting,
+  util.add(2, 3),
+  add(20, 22),
+  new util.default().value,
+  Object.keys(util).sort(),
+  typeof util.add,
+];
+for (const v of values) console.log(JSON.stringify(v));
+`, {
+            name: "diff_namespace_import",
+            files: {
+                "util.ts": [
+                    'export const greeting = "hello";',
+                    "export function add(a: number, b: number): number { return a + b; }",
+                    "export default class Thing { value = 42; }",
+                    "export const ignored = 1;\n",
+                ].join("\n"),
+            },
+        });
+    });
+});
+//# sourceMappingURL=differential.test.js.map

package/dist/tests/e2e/differential.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"differential.test.js","sourceRoot":"","sources":["../../../tests/e2e/differential.test.ts"],"names":[],"mappings":"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"}

package/dist/tests/e2e/harness.d.ts

@@ -12,12 +12,22 @@ export interface RunOptions {
     force?: boolean;
     /** Child-process timeout in milliseconds. */
     timeout?: number;
+    /** Extra modules written next to the entry file, keyed by relative path. */
+    files?: Record<string, string>;
 }
 export interface RunResult {
     stdout: string;
     stderr: string;
     status: number | null;
 }
+export interface NodeRunOptions {
+    /** Entry file base name; defaults to a random name. */
+    name?: string;
+    /** Child-process timeout in milliseconds. */
+    timeout?: number;
+    /** Extra modules written next to the entry file, keyed by relative path. */
+    files?: Record<string, string>;
+}
 export interface E2EHarness {
     /** Scratch directory shared by the tests in the calling suite. */
     readonly workdir: string;
@@ -25,6 +35,17 @@ export interface E2EHarness {
     runProgram(source: string, options?: RunOptions): string;
     /** Compile and run `source` without asserting the exit status. */
     runProgramFull(source: string, options?: RunOptions): RunResult;
+    /**
+     * Run `source` under Node (through the `tsx` loader) and return its trimmed
+     * stdout. Differential cases should print canonical `JSON.stringify` output
+     * so console formatting never masks a real difference.
+     */
+    runNodeProgram(source: string, options?: NodeRunOptions): string;
+    /**
+     * Compile `source` with xbintsc and run it under Node, asserting both produce
+     * byte-identical stdout. This is the core differential-testing primitive.
+     */
+    expectSameOutputAsNode(source: string, options?: RunOptions): void;
 }
 /**
  * Declare a suite of end-to-end compilation tests. The `define` callback runs

package/dist/tests/e2e/harness.js

@@ -31,6 +31,9 @@ export function describeE2E(name, define, options = {}) {
         });
         const runProgramFull = (source, runOptions = {}) => {
             const entry = join(workdir, `${runOptions.name ?? `program_${Math.random().toString(36).slice(2)}`}.ts`);
+            for (const [relative, contents] of Object.entries(runOptions.files ?? {})) {
+                writeFileSync(join(workdir, relative), contents);
+            }
             writeFileSync(entry, source);
             const extensions = runOptions.extensions ? createDefaultRegistry().register(nodeExtension) : undefined;
             const result = build(entry, {
@@ -47,6 +50,19 @@ export function describeE2E(name, define, options = {}) {
             });
             return { stdout: executed.stdout ?? "", stderr: executed.stderr ?? "", status: executed.status };
         };
+        const runNodeProgram = (source, runOptions = {}) => {
+            const entry = join(workdir, `${runOptions.name ?? `node_${Math.random().toString(36).slice(2)}`}.ts`);
+            for (const [relative, contents] of Object.entries(runOptions.files ?? {})) {
+                writeFileSync(join(workdir, relative), contents);
+            }
+            writeFileSync(entry, source);
+            const executed = spawnSync(process.execPath, ["--import", "tsx", entry], {
+                encoding: "utf8",
+                ...(runOptions.timeout ? { timeout: runOptions.timeout } : {}),
+            });
+            expect(executed.status).toBe(0);
+            return (executed.stdout ?? "").trim();
+        };
         const harness = {
             get workdir() {
                 return workdir;
@@ -57,6 +73,16 @@ export function describeE2E(name, define, options = {}) {
                 return result.stdout.trim();
             },
             runProgramFull,
+            runNodeProgram,
+            expectSameOutputAsNode(source, runOptions = {}) {
+                const ours = harness.runProgram(source, runOptions);
+                const theirs = runNodeProgram(source, {
+                    ...(runOptions.name ? { name: runOptions.name } : {}),
+                    ...(runOptions.timeout ? { timeout: runOptions.timeout } : {}),
+                    ...(runOptions.files ? { files: runOptions.files } : {}),
+                });
+                expect(ours).toBe(theirs);
+            },
         };
         define(harness);
     });