xbintsc 0.3.87 → 0.5.20

package/dist/tests/e2e/async-await.test.js

@@ -0,0 +1,247 @@
+/**
+ * End-to-end tests for *real* `async`/`await` suspension.
+ *
+ * An `async` function runs its body on a stackful coroutine. When it awaits a
+ * promise that has not settled yet, the coroutine suspends and the event loop
+ * (timers, sockets, ...) takes over; the promise's settlement resumes the
+ * coroutine exactly where it stopped. These tests therefore depend on work that
+ * can only complete after the program body returns.
+ */
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+import { makeDifferential } from "./differential-helpers.js";
+const prelude = `
+function sleep(ms: number): Promise<void> {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+`;
+describeE2E("end-to-end real async/await", (harness) => {
+    const { runProgram } = harness;
+    const { diff } = makeDifferential(harness);
+    diff("resumes an async function after a timer settles its promise", `${prelude}
+const order: string[] = [];
+async function main(): Promise<void> {
+  order.push("start");
+  await sleep(5);
+  order.push("timer");
+  const value = await new Promise<number>((resolve) => setTimeout(() => resolve(7), 1));
+  order.push("value:" + value);
+}
+main().then(() => {
+  order.push("done");
+  console.log(order.join(","));
+});
+console.log("body");`);
+    it("keeps the program alive until an awaited timer resolves", () => {
+        const source = `${prelude}
+async function main(): Promise<void> {
+  await sleep(10);
+  console.log("after");
+}
+main();
+console.log("before");`;
+        expect(runProgram(source)).toBe("before\nafter");
+    });
+    it("runs independent async functions concurrently", () => {
+        /* Do not assert which timer fires first: Windows timer granularity can
+         * batch 1ms and 8ms deadlines into the same reactor turn. Instead observe
+         * that both bodies reach their `await` before either resumes (peak 2),
+         * and that `Promise.all` keeps the array order regardless of completion
+         * order. */
+        const source = `${prelude}
+let active = 0;
+let peak = 0;
+async function task(ms: number): Promise<number> {
+  active++;
+  if (active > peak) peak = active;
+  await sleep(ms);
+  active--;
+  return ms;
+}
+async function main(): Promise<void> {
+  const results = await Promise.all([task(8), task(1)]);
+  console.log("peak", peak, "results", results.join(","));
+}
+main();`;
+        expect(runProgram(source)).toBe("peak 2 results 8,1");
+    });
+    it("finishes independent async functions in delay order with long timers", () => {
+        /* The timers are far enough apart (50ms vs 200ms) that even a platform
+         * with ~15ms timer granularity cannot merge them into one reactor turn, so
+         * completion order is observable and deterministic. */
+        const source = `${prelude}
+const order: string[] = [];
+async function task(name: string, ms: number): Promise<void> {
+  await sleep(ms);
+  order.push(name);
+}
+async function main(): Promise<void> {
+  await Promise.all([task("slow", 200), task("fast", 50)]);
+  console.log(order.join(","));
+}
+main();`;
+        expect(runProgram(source)).toBe("fast,slow");
+    });
+    it("rejects when an awaited timer promise rejects and is catchable", () => {
+        const source = `${prelude}
+function fail(ms: number): Promise<number> {
+  return new Promise<number>((_resolve, reject) => setTimeout(() => reject("boom"), ms));
+}
+async function main(): Promise<void> {
+  try {
+    await fail(2);
+    console.log("unreachable");
+  } catch (error) {
+    console.log("caught", error);
+  }
+  try {
+    await fail(1);
+  } finally {
+    console.log("finally");
+  }
+}
+main();`;
+        expect(runProgram(source)).toBe("caught boom\nfinally");
+    });
+    it("rejects the returned promise when the body throws after resuming", () => {
+        const source = `${prelude}
+async function boom(): Promise<void> {
+  await sleep(1);
+  throw new Error("late");
+}
+boom().catch((error: any) => console.log("rejected", error.message));`;
+        expect(runProgram(source)).toBe("rejected late");
+    });
+    it("suspends across loops, closures and nested async calls", () => {
+        const source = `${prelude}
+async function twice(n: number): Promise<number> {
+  await sleep(1);
+  return n * 2;
+}
+async function sum(limit: number): Promise<number> {
+  let total = 0;
+  for (let i = 0; i < limit; i++) {
+    total += await twice(i);
+  }
+  return total;
+}
+async function main(): Promise<void> {
+  const total = await sum(4);
+  console.log("total", total);
+}
+main();`;
+        expect(runProgram(source)).toBe("total 12");
+    });
+    it("resumes two coroutines waiting on the same promise", () => {
+        const source = `${prelude}
+async function main(): Promise<void> {
+  const shared = new Promise<string>((resolve) => setTimeout(() => resolve("shared"), 3));
+  const results = await Promise.all([
+    (async () => "a:" + (await shared))(),
+    (async () => "b:" + (await shared))(),
+  ]);
+  console.log(results.join(" "));
+}
+main();`;
+        expect(runProgram(source)).toBe("a:shared b:shared");
+    });
+    it("awaits a promise resolved by a socket callback", () => {
+        const source = `
+import net from "node:net";
+
+function once(socket: any, event: string): Promise<any> {
+  return new Promise<any>((resolve) => socket.on(event, resolve));
+}
+
+async function main(): Promise<void> {
+  const server = net.createServer((socket: any) => {
+    socket.on("data", (data: any) => {
+      socket.write("echo:" + data);
+      socket.end();
+    });
+  });
+  server.listen(0, () => {});
+  await new Promise<void>((resolve) => server.on("listening", resolve));
+  const client = net.connect(server.address().port, "127.0.0.1");
+  client.write("ping");
+  const data = await once(client, "data");
+  await once(client, "end");
+  server.close();
+  console.log("client", data);
+}
+main();`;
+        expect(runProgram(source, { extensions: true })).toBe("client echo:ping");
+    });
+    it("awaits fs/promises across an event-loop turn", () => {
+        const base = `${JSON.stringify(harness.workdir)} + "/async-fs-" + Math.random().toString(36).slice(2)`;
+        const source = `
+import { promises as fsp } from "fs";
+
+async function main(): Promise<void> {
+  const base = ${base};
+  await fsp.mkdir(base, { recursive: true });
+  const order: string[] = [];
+  setTimeout(() => order.push("timer"), 1);
+  await fsp.writeFile(base + "/a.txt", "hello");
+  order.push("write");
+  const text = await fsp.readFile(base + "/a.txt", "utf8");
+  order.push("read:" + text);
+  await new Promise<void>((resolve) => setTimeout(resolve, 5));
+  order.push("waited");
+  console.log(order.join(","));
+  await fsp.rm(base, { recursive: true, force: true });
+}
+main();`;
+        expect(runProgram(source, { extensions: true })).toBe("write,read:hello,timer,waited");
+    });
+    it("keeps a pending await alive while unrelated timers fire", () => {
+        const source = `${prelude}
+const log: string[] = [];
+async function main(): Promise<void> {
+  setTimeout(() => log.push("early"), 1);
+  await sleep(6);
+  log.push("late");
+  console.log(log.join(","));
+}
+main();`;
+        expect(runProgram(source)).toBe("early,late");
+    });
+    it("runs async callbacks scheduled by then() and setTimeout()", () => {
+        const source = `${prelude}
+Promise.resolve().then(async () => {
+  await sleep(1);
+  console.log("then");
+});
+setTimeout(async () => {
+  await sleep(1);
+  console.log("timer");
+}, 2);`;
+        expect(runProgram(source)).toBe("then\ntimer");
+    });
+    it("awaits a top-level promise by blocking on the event loop", () => {
+        const source = `${prelude}
+await sleep(50);
+console.log("top-level");`;
+        expect(runProgram(source)).toBe("top-level");
+    });
+    it("keeps suspended coroutines reachable across collections", () => {
+        const source = `${prelude}
+async function worker(id: number): Promise<number> {
+  let total = 0;
+  for (let i = 0; i < 20; i++) {
+    const junk: any[] = [];
+    for (let j = 0; j < 10; j++) junk.push({ id, i, j, text: "x".repeat(40) + j });
+    await sleep(i % 2);
+    total += junk.length;
+  }
+  return total;
+}
+async function main(): Promise<void> {
+  const results = await Promise.all([worker(1), worker(2)]);
+  console.log("alive", results.join(","));
+}
+main();`;
+        expect(runProgram(source, { env: { XT_GC_THRESHOLD: "1048576" }, timeout: 60000 })).toBe("alive 200,200");
+    });
+});
+//# sourceMappingURL=async-await.test.js.map

package/dist/tests/e2e/async-await.test.js.map

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

package/dist/tests/e2e/async-generators.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/e2e/async-generators.test.js

@@ -0,0 +1,154 @@
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+/**
+ * `async function*` and `for await...of` are backed by the same stackful
+ * coroutine as generators and async functions. The body can await a timer and
+ * still resume at the right yield, and every `.next()` request gets a promise.
+ */
+describeE2E("async generators and for await...of", (harness) => {
+    it("yields across awaits and completes with a return value", () => {
+        harness.expectSameOutputAsNode(`
+      async function* count(limit: number) {
+        for (let i = 0; i < limit; i++) {
+          await Promise.resolve(i);
+          yield i * 2;
+        }
+        return 99;
+      }
+      async function main() {
+        const values: number[] = [];
+        for await (const value of count(3)) values.push(value);
+        const it = count(2);
+        const first = await it.next();
+        const second = await it.next();
+        const done = await it.next();
+        console.log(JSON.stringify({ values, first, second, done }));
+      }
+      main();
+    `);
+    });
+    it("suspends on a timer between yields", () => {
+        harness.expectSameOutputAsNode(`
+      async function delay(ms: number) {
+        return new Promise<void>((resolve) => setTimeout(resolve, ms));
+      }
+      async function* timed() {
+        yield "a";
+        await delay(2);
+        yield "b";
+      }
+      async function main() {
+        const log: string[] = [];
+        setTimeout(() => log.push("timer"), 0);
+        for await (const value of timed()) log.push("yield:" + value);
+        console.log(log.join(","));
+      }
+      main();
+    `);
+    });
+    it("supports throw, catch and finally inside the body", () => {
+        harness.expectSameOutputAsNode(`
+      async function* catching() {
+        try {
+          yield 1;
+          yield 2;
+        } catch (error) {
+          yield "caught:" + (error as Error).message;
+        } finally {
+          yield "finally";
+        }
+      }
+      async function main() {
+        const it = catching();
+        const out: string[] = [];
+        out.push(JSON.stringify(await it.next()));
+        out.push(JSON.stringify(await it.throw(new Error("boom"))));
+        out.push(JSON.stringify(await it.next()));
+        out.push(JSON.stringify(await it.next()));
+        console.log(out.join("\\n"));
+      }
+      main();
+    `);
+    });
+    it("iterates sync generators, arrays and custom async iterables", () => {
+        harness.expectSameOutputAsNode(`
+      function* syncValues() { yield 1; yield 2; }
+      const custom = {
+        [Symbol.asyncIterator]() {
+          let i = 0;
+          return {
+            next() {
+              i++;
+              if (i <= 2) return Promise.resolve({ value: i * 10, done: false });
+              return Promise.resolve({ value: undefined, done: true });
+            },
+          };
+        },
+      };
+      async function main() {
+        const out: number[] = [];
+        for await (const value of syncValues()) out.push(value);
+        for await (const value of [3, 4]) out.push(value);
+        for await (const value of custom) out.push(value);
+        console.log(out.join(","));
+      }
+      main();
+    `);
+    });
+    it("keeps a suspended async generator and its await chain alive across collections", () => {
+        harness.expectSameOutputAsNode(`
+      async function* range(n: number) {
+        const buf: number[] = [];
+        for (let i = 0; i < n; i++) {
+          const hold = { i, text: "v" + i };
+          await Promise.resolve(i);
+          buf.push(hold.i);
+          yield buf.length;
+        }
+      }
+      async function main() {
+        let sum = 0;
+        for await (const value of range(300)) {
+          const garbage = "x".repeat(40) + value;
+          sum += garbage.length;
+        }
+        console.log(sum);
+      }
+      main();
+    `, { env: { XT_GC_THRESHOLD: "1" } });
+    });
+    it("resolves queued next() calls in order", () => {
+        harness.expectSameOutputAsNode(`
+      async function* values() { yield 1; yield 2; }
+      async function main() {
+        const it = values();
+        const first = it.next();
+        const second = it.next();
+        console.log(JSON.stringify(await first), JSON.stringify(await second));
+      }
+      main();
+    `);
+    });
+    it("returns done from return() and rejects an escaped throw", () => {
+        harness.expectSameOutputAsNode(`
+      async function* values() { yield 1; }
+      async function* failing() { yield 1; throw new Error("bad"); }
+      async function main() {
+        const it = values();
+        const returned = await it.return(7);
+        const after = await it.next();
+        const f = failing();
+        const first = await f.next();
+        let message = "";
+        try {
+          await f.next();
+        } catch (error) {
+          message = (error as Error).message;
+        }
+        console.log(JSON.stringify({ returned, after, first, message }));
+      }
+      main();
+    `);
+    });
+});
+//# sourceMappingURL=async-generators.test.js.map

package/dist/tests/e2e/async-generators.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-generators.test.js","sourceRoot":"","sources":["../../../tests/e2e/async-generators.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;GAIG;AACH,WAAW,CAAC,qCAAqC,EAAE,CAAC,OAAO,EAAE,EAAE;IAC7D,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;KAkB9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAC5C,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;KAgB9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mDAAmD,EAAE,GAAG,EAAE;QAC3D,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;KAqB9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACrE,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;KAsB9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gFAAgF,EAAE,GAAG,EAAE;QACxF,OAAO,CAAC,sBAAsB,CAC5B;;;;;;;;;;;;;;;;;;;KAmBD,EACC,EAAE,GAAG,EAAE,EAAE,eAAe,EAAE,GAAG,EAAE,EAAE,CAClC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uCAAuC,EAAE,GAAG,EAAE;QAC/C,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;KAS9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;KAkB9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/await-ordering.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `await` always yields once, even for a non-promise or an already-settled
+ * promise, so it interleaves with pending `.then` callbacks exactly like Node.
+ */
+export {};

package/dist/tests/e2e/await-ordering.test.js

@@ -0,0 +1,37 @@
+/**
+ * `await` always yields once, even for a non-promise or an already-settled
+ * promise, so it interleaves with pending `.then` callbacks exactly like Node.
+ */
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("await microtask ordering", (harness) => {
+    it("yields for non-promises and settled promises", () => {
+        harness.expectSameOutputAsNode(`
+      async function run(): Promise<void> {
+        console.log("a");
+        await 1;
+        console.log("b");
+        await Promise.resolve(2);
+        console.log("c");
+      }
+      run();
+      console.log("caller");
+      Promise.resolve().then(() => console.log("then1"));
+    `);
+    });
+    it("queues rejection handling in the same order as Node", () => {
+        harness.expectSameOutputAsNode(`
+      async function run(): Promise<void> {
+        try {
+          await Promise.reject("boom");
+        } catch (error) {
+          console.log("caught", error);
+        }
+      }
+      run();
+      console.log("sync");
+      Promise.resolve().then(() => console.log("then"));
+    `);
+    });
+});
+//# sourceMappingURL=await-ordering.test.js.map

package/dist/tests/e2e/await-ordering.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"await-ordering.test.js","sourceRoot":"","sources":["../../../tests/e2e/await-ordering.test.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,0BAA0B,EAAE,CAAC,OAAO,EAAE,EAAE;IAClD,EAAE,CAAC,8CAA8C,EAAE,GAAG,EAAE;QACtD,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;KAW9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC7D,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;KAW9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/compile-builtins.test.js

@@ -131,7 +131,7 @@ describeE2E("end-to-end built-in library", (harness) => {
       main();
       Promise.resolve(10).then((x) => console.log("then", x + 1));
     `;
-        expect(runProgram(source)).toBe("hello world\n3\nfulfilled rejected\ncaught boom\nthen 11");
+        expect(runProgram(source)).toBe("hello world\nthen 11\n3\nfulfilled rejected\ncaught boom");
     });
     it("supports Map, Set, JSON and extended standard library methods", () => {
         const source = `

package/dist/tests/e2e/compile-modules.test.js

@@ -44,5 +44,12 @@ describeE2E("end-to-end module bundling", (harness) => {
             },
         })).toBe("5");
     });
+    it("evaluates a side-effect-only import before the importer", () => {
+        const source = `
+      import "./side_effect";
+      console.log("main");
+    `;
+        expect(runProgram(source, { files: { "side_effect.ts": 'console.log("side");' } })).toBe("side\nmain");
+    });
 });
 //# sourceMappingURL=compile-modules.test.js.map

package/dist/tests/e2e/compile-modules.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"compile-modules.test.js","sourceRoot":"","sources":["../../../tests/e2e/compile-modules.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,4BAA4B,EAAE,CAAC,OAAO,EAAE,EAAE;IACpD,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAE/B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,aAAa,CACX,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,EACpC;;;;;;;;OAQC,CACF,CAAC;QACF,MAAM,MAAM,GAAG;;;;KAId,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,0BAA0B,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CACJ,UAAU,CAAC,MAAM,EAAE;YACjB,KAAK,EAAE;gBACL,WAAW,EAAE,kCAAkC;gBAC/C,YAAY,EAAE,6CAA6C;aAC5D;SACF,CAAC,CACH,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}
+{"version":3,"file":"compile-modules.test.js","sourceRoot":"","sources":["../../../tests/e2e/compile-modules.test.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,4BAA4B,EAAE,CAAC,OAAO,EAAE,EAAE;IACpD,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAE/B,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,aAAa,CACX,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,EACpC;;;;;;;;OAQC,CACF,CAAC;QACF,MAAM,MAAM,GAAG;;;;KAId,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;IACpD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;QAC/D,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,0BAA0B,CAAC,CAAC;QAC/E,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2DAA2D,EAAE,GAAG,EAAE;QACnE,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CACJ,UAAU,CAAC,MAAM,EAAE;YACjB,KAAK,EAAE;gBACL,WAAW,EAAE,kCAAkC;gBAC/C,YAAY,EAAE,6CAA6C;aAC5D;SACF,CAAC,CACH,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACd,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,MAAM,GAAG;;;KAGd,CAAC;QACF,MAAM,CACJ,UAAU,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,EAAE,CAAC,CAC5E,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/date-parse.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `Date.parse` / `new Date(string)` for ISO 8601 input.
+ *
+ * Both used to score every string as 0 (the epoch), so a parsed date silently
+ * became 1970-01-01. The supported subset is date-only (`YYYY-MM-DD`, UTC),
+ * optional `THH:MM[:SS[.mmm]]`, and a `Z` / `±HH:MM` / `±HHMM` offset.
+ */
+export {};

package/dist/tests/e2e/date-parse.test.js

@@ -0,0 +1,38 @@
+/**
+ * `Date.parse` / `new Date(string)` for ISO 8601 input.
+ *
+ * Both used to score every string as 0 (the epoch), so a parsed date silently
+ * became 1970-01-01. The supported subset is date-only (`YYYY-MM-DD`, UTC),
+ * optional `THH:MM[:SS[.mmm]]`, and a `Z` / `±HH:MM` / `±HHMM` offset.
+ */
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("Date parsing", (harness) => {
+    it("parses ISO 8601 strings like Node", () => {
+        harness.expectSameOutputAsNode(`
+      console.log(Date.parse("2020-01-01T00:00:00.000Z"));
+      console.log(new Date("2020-01-01T12:30:15.250+02:00").toISOString());
+      console.log(
+        new Date("2020-01-01").getUTCFullYear(),
+        new Date("2020-01-01").getUTCMonth(),
+        new Date("2020-01-01").getUTCDate(),
+      );
+      console.log(Number.isNaN(Date.parse("not a date")));
+      console.log(Number.isNaN(new Date("nope").getTime()));
+      console.log(new Date("2020-02-29T00:00:00Z").toISOString());
+      console.log(Number.isNaN(Date.parse("2020-02-30")));
+      console.log(new Date("2020-06-15 08:05:00Z").toISOString());
+      console.log(new Date("2020-06-15T08:05:00+0800").toISOString());
+    `);
+    });
+    it("throws a RangeError for toISOString on an invalid date", () => {
+        harness.expectSameOutputAsNode(`
+      try {
+        new Date("nope").toISOString();
+      } catch (e: any) {
+        console.log(e instanceof RangeError, e.name);
+      }
+    `);
+    });
+});
+//# sourceMappingURL=date-parse.test.js.map

package/dist/tests/e2e/date-parse.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-parse.test.js","sourceRoot":"","sources":["../../../tests/e2e/date-parse.test.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,cAAc,EAAE,CAAC,OAAO,EAAE,EAAE;IACtC,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAC3C,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;;;KAc9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wDAAwD,EAAE,GAAG,EAAE;QAChE,OAAO,CAAC,sBAAsB,CAAC;;;;;;KAM9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/default-anonymous-exports.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `export default function () {}` / `export default class {}` are valid
+ * TypeScript. They used to crash the binder because the declaration has no
+ * name; the parser now gives them the internal binding name `default` so the
+ * bundler can map the default export like any other.
+ */
+export {};

package/dist/tests/e2e/default-anonymous-exports.test.js

@@ -0,0 +1,23 @@
+/**
+ * `export default function () {}` / `export default class {}` are valid
+ * TypeScript. They used to crash the binder because the declaration has no
+ * name; the parser now gives them the internal binding name `default` so the
+ * bundler can map the default export like any other.
+ */
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("anonymous default exports", (harness) => {
+    it("imports an anonymous default function and class", () => {
+        harness.expectSameOutputAsNode(`
+        import fn from "./lib-fn.ts";
+        import C from "./lib-class.ts";
+        console.log(fn(), new C().x, new C() instanceof C);
+      `, {
+            files: {
+                "lib-fn.ts": "export default function () { return 7; }",
+                "lib-class.ts": "export default class { x = 1; }",
+            },
+        });
+    });
+});
+//# sourceMappingURL=default-anonymous-exports.test.js.map

package/dist/tests/e2e/default-anonymous-exports.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-anonymous-exports.test.js","sourceRoot":"","sources":["../../../tests/e2e/default-anonymous-exports.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,2BAA2B,EAAE,CAAC,OAAO,EAAE,EAAE;IACnD,EAAE,CAAC,iDAAiD,EAAE,GAAG,EAAE;QACzD,OAAO,CAAC,sBAAsB,CAC5B;;;;OAIC,EACD;YACE,KAAK,EAAE;gBACL,WAAW,EAAE,0CAA0C;gBACvD,cAAc,EAAE,iCAAiC;aAClD;SACF,CACF,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/globals-microtask.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Node globals that sit on the event loop: `queueMicrotask`, `setImmediate`,
+ * `clearImmediate` and `performance.now`.
+ *
+ * queueMicrotask shares the promise reaction queue (FIFO), setImmediate is a
+ * zero-delay timer that forwards extra arguments, and performance.now reads a
+ * monotonic clock with sub-millisecond resolution.
+ */
+export {};

package/dist/tests/e2e/globals-microtask.test.js

@@ -0,0 +1,37 @@
+/**
+ * Node globals that sit on the event loop: `queueMicrotask`, `setImmediate`,
+ * `clearImmediate` and `performance.now`.
+ *
+ * queueMicrotask shares the promise reaction queue (FIFO), setImmediate is a
+ * zero-delay timer that forwards extra arguments, and performance.now reads a
+ * monotonic clock with sub-millisecond resolution.
+ */
+import { it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("microtask and immediate globals", (harness) => {
+    it("orders microtasks, supports first-class values and performance.now", () => {
+        harness.expectSameOutputAsNode(`
+      queueMicrotask(() => console.log("micro"));
+      Promise.resolve().then(() => console.log("promise"));
+      queueMicrotask(() => console.log("micro2"));
+
+      console.log(typeof performance.now(), performance.now() > 0, typeof performance.now);
+      const now = performance.now;
+      console.log(typeof now);
+
+      setImmediate((a: number, b: number) => console.log("immediate", a, b), 1, 2);
+      const cancelled = setImmediate(() => console.log("cancelled"));
+      clearImmediate(cancelled);
+    `);
+    });
+    it("rejects a non-function microtask callback", () => {
+        harness.expectSameOutputAsNode(`
+      try {
+        queueMicrotask(1 as any);
+      } catch (e: any) {
+        console.log(e instanceof TypeError, e.name);
+      }
+    `);
+    });
+});
+//# sourceMappingURL=globals-microtask.test.js.map

package/dist/tests/e2e/globals-microtask.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals-microtask.test.js","sourceRoot":"","sources":["../../../tests/e2e/globals-microtask.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,iCAAiC,EAAE,CAAC,OAAO,EAAE,EAAE;IACzD,EAAE,CAAC,oEAAoE,EAAE,GAAG,EAAE;QAC5E,OAAO,CAAC,sBAAsB,CAAC;;;;;;;;;;;;KAY9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2CAA2C,EAAE,GAAG,EAAE;QACnD,OAAO,CAAC,sBAAsB,CAAC;;;;;;KAM9B,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/gui-media.test.js

@@ -26,7 +26,14 @@ function mediaSrc(absolutePath) {
     return absolutePath.split("\\").join("/");
 }
 const resourcesAvailable = existsSync(moviePath) && existsSync(soundPath);
-describe.skipIf(!guiAvailable || !resourcesAvailable)("gui extension — media", () => {
+/**
+ * Windows builds the GUI archive without FFmpeg on purpose (see
+ * `doc/gui/known-issues.md`), so media elements are inert there and the suite
+ * would only report the expected `error` events as failures. It stays skipped
+ * even with `xbintsc_GUI_TESTS=1`.
+ */
+const mediaAvailable = process.platform !== "win32";
+describe.skipIf(!guiAvailable || !resourcesAvailable || !mediaAvailable)("gui extension — media", () => {
     const harness = createGuiHarness();
     beforeAll(() => harness.setup());
     afterAll(() => harness.cleanup());