xbintsc 0.3.81 → 0.5.6

package/dist/tests/e2e/string-concat.test.js

@@ -0,0 +1,102 @@
+/**
+ * End-to-end tests for the lazy (rope/cons) string model.
+ *
+ * Concatenation above the eager-copy threshold produces an immutable cons node
+ * whose bytes are materialised on first observation. These tests exercise every
+ * kind of observation (length, slicing, searching, case changes, JSON, property
+ * keys) and keep chains reachable across a garbage collection.
+ */
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("lazy string concatenation", (harness) => {
+    const { runProgram, runProgramFull } = harness;
+    it("matches Node for append and prepend chains", () => {
+        const source = `
+function build(n: number): string {
+  let text = "";
+  for (let i = 0; i < n; i++) text = text + "abcdefghijklmnopqrstuvwxyz".charAt(i % 26);
+  return text;
+}
+const text = build(2000);
+console.log(text.length);
+console.log(text.slice(0, 26));
+console.log(text.slice(-26));
+console.log(text.indexOf("xyz"));
+console.log(text.lastIndexOf("abc"));
+console.log(text.includes("mnop"));
+console.log(text.split("def").length);
+console.log(text.toUpperCase().slice(0, 26));
+console.log(text.replace("abc", "ABC").slice(0, 26));
+console.log(text.replaceAll("a", "!").slice(0, 26));
+console.log(text === build(2000));
+console.log(text.startsWith("abc"), text.endsWith("xyz"));
+console.log(JSON.stringify(text.slice(0, 10)));
+console.log(text.charCodeAt(5), text.at(-1));
+
+let prepended = "";
+for (let i = 0; i < 2000; i++) prepended = "x" + prepended;
+console.log(prepended.length, prepended.slice(0, 3), prepended.slice(-3));
+
+let mixed = "";
+for (let i = 0; i < 200; i++) mixed += i;
+console.log(mixed.length, mixed.slice(0, 12));
+
+let templated = "";
+for (let i = 0; i < 2000; i++) templated = \`\${templated}\${i % 10}\`;
+console.log(templated.length, templated.slice(0, 12));
+
+let key = "";
+for (let i = 0; i < 40; i++) key += "k";
+const holder: any = {};
+holder[key] = "v";
+console.log(holder[key], Object.keys(holder)[0].length);
+console.log([text, prepended].join("|").length);
+`;
+        harness.expectSameOutputAsNode(source, { name: "string_concat_chains" });
+    });
+    it("keeps cons nodes reachable across collections", () => {
+        const source = `
+let text = "";
+for (let i = 0; i < 2000; i++) text += "z";
+const holder: any = { text: text };
+const list: any[] = [text];
+text = "";
+
+/* Allocate and drop many objects to force collections while the rope is
+   reachable only through the object property and the array element. */
+let junk: any = {};
+for (let i = 0; i < 40000; i++) junk = { value: i };
+junk = {};
+const trigger = "x" + "y";
+
+/* Reuse the freed memory before the rope is ever flattened. */
+const reuse: any[] = [];
+for (let i = 0; i < 5000; i++) reuse.push("a" + "b");
+
+console.log(holder.text.length, holder.text === "z".repeat(2000));
+console.log(list[0].length, list[0] === holder.text, reuse.length, trigger);
+console.log(holder.text.slice(0, 2), holder.text.slice(-2), holder.text.toUpperCase().slice(0, 3));
+`;
+        const result = runProgramFull(source, {
+            name: "string_concat_gc",
+            env: { XT_GC_THRESHOLD: "1048576" },
+            timeout: 60000,
+        });
+        expect(result.status).toBe(0);
+        expect(result.stdout.trim()).toBe("2000 true\n2000 true 5000 xy\nzz zz ZZZ");
+    });
+    it("flattens reused chains without mutating earlier results", () => {
+        const source = `
+let prefix = "start-";
+for (let i = 0; i < 200; i++) prefix += "p";
+const first = prefix + "-first";
+const second = prefix + "-second";
+const prefixCopy = prefix.slice(0);
+console.log(first.slice(-6), second.slice(-7));
+console.log(prefix.length, first.length, second.length);
+console.log(prefix === prefixCopy, prefix === first.slice(0, prefix.length));
+`;
+        expect(runProgram(source)).toBe("-first -second\n206 212 213\ntrue true");
+    });
+});
+//# sourceMappingURL=string-concat.test.js.map

package/dist/tests/e2e/string-concat.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-concat.test.js","sourceRoot":"","sources":["../../../tests/e2e/string-concat.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,2BAA2B,EAAE,CAAC,OAAO,EAAE,EAAE;IACnD,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAE/C,EAAE,CAAC,4CAA4C,EAAE,GAAG,EAAE;QACpD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwClB,CAAC;QACE,OAAO,CAAC,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACvD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;CAqBlB,CAAC;QACE,MAAM,MAAM,GAAG,cAAc,CAAC,MAAM,EAAE;YACpC,IAAI,EAAE,kBAAkB;YACxB,GAAG,EAAE,EAAE,eAAe,EAAE,SAAS,EAAE;YACnC,OAAO,EAAE,KAAK;SACf,CAAC,CAAC;QACH,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9B,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;IAC/E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;QACjE,MAAM,MAAM,GAAG;;;;;;;;;CASlB,CAAC;QACE,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IAC5E,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/e2e/string-utf16.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Differential coverage for JavaScript's UTF-16 string view over the runtime's
+ * UTF-8 storage: `length`, indexing, slicing, searching, splitting, padding,
+ * iteration, surrogate round-trips, JSON and RegExp offsets.
+ */
+export {};

package/dist/tests/e2e/string-utf16.test.js

@@ -0,0 +1,133 @@
+/**
+ * Differential coverage for JavaScript's UTF-16 string view over the runtime's
+ * UTF-8 storage: `length`, indexing, slicing, searching, splitting, padding,
+ * iteration, surrogate round-trips, JSON and RegExp offsets.
+ */
+import { expect, it } from "vitest";
+import { describeE2E } from "./harness.js";
+describeE2E("UTF-16 string semantics", (harness) => {
+    const { runProgram, expectSameOutputAsNode } = harness;
+    it("matches Node for length, indexing, slicing and searching", () => {
+        const source = `
+const s = "中文😀aé";
+const show = (v: unknown) => console.log(JSON.stringify(v));
+show(s.length);
+for (let i = 0; i < s.length; i++) show(s[i]);
+for (let i = 0; i <= s.length; i++) show(s.codePointAt(i));
+show(s.slice(0, 4));
+show(s.slice(1, 5));
+show(s.slice(2, 3));
+show(s.slice(3, 4));
+show(s.slice(-3));
+show(s.substring(3, 1));
+show(s.substring(1, 100));
+show(s.substr(2, 2));
+show(s.substr(-2));
+show(s.charAt(2));
+show(s.charCodeAt(2));
+show(s.at(-1));
+show(s.at(-5));
+show(s.indexOf("😀"));
+show(s.indexOf("a", 4));
+show(s.indexOf("", 100));
+show(s.lastIndexOf("中"));
+show(s.lastIndexOf("😀", 3));
+show(s.lastIndexOf("a", 2));
+show(s.includes("😀"));
+show(s.includes("文", 2));
+show(s.startsWith("中文"));
+show(s.startsWith("😀", 2));
+show(s.endsWith("aé"));
+show(s.endsWith("😀", 4));
+show(s.split("😀"));
+show(s.split("", 4));
+show(s.split("a"));
+show("😀".repeat(3));
+show("x".padStart(4, "😀"));
+show("x".padEnd(4, "😀"));
+show("中".padStart(3, "ab"));
+show("a😀b中".startsWith("😀", 2));
+show("a😀b中".indexOf("😀", 2));
+show("a😀b中".endsWith("a", 2));
+show("a😀b中".lastIndexOf("😀", 2));
+show("a😀b中".lastIndexOf("\\uDE00", 2));
+show(s.length === 6);
+`;
+        expectSameOutputAsNode(source, { name: "utf16_indexing" });
+    });
+    it("matches Node for iteration, keys, surrogate round-trips and JSON", () => {
+        const source = `
+const s = "中文😀aé";
+const show = (v: unknown) => console.log(JSON.stringify(v));
+show([...s]);
+show(Array.from(s));
+show(Object.keys(s));
+show(Object.values("😀"));
+show(Object.entries("😀"));
+const high = "\\uD83D";
+const low = "\\uDE00";
+show(high + low);
+show((high + low).length);
+show((high + low) === "😀");
+show(String.fromCharCode(0x4e2d, 0xd83d, 0xde00));
+show(String.fromCharCode(0x10000));
+show(String.fromCodePoint(0x1f600));
+show(String.fromCodePoint(0x4e2d));
+show(JSON.stringify("\\uD83D"));
+show(JSON.stringify("\\uDE00"));
+show(JSON.stringify("\\uD83D\\uDE00"));
+show(JSON.stringify("\\u{1F600}"));
+show("\\u{1F600}".length);
+show("\\u4e2d".length);
+show(JSON.stringify(JSON.parse('"\\\\u4e2d\\\\ud83d\\\\ude00"')));
+show(JSON.parse('"\\\\ud83d\\\\ude00"').length);
+show(JSON.parse('"\\\\ud83d"').length);
+let built = "";
+for (const ch of s) built += ch;
+show(built);
+show(built === s);
+let keys = "";
+for (const key in "😀") keys += key;
+show(keys);
+show(JSON.stringify({ ..."😀" }));
+show("a😀".replaceAll("", "-"));
+show("a😀".replaceAll("😀", "中"));
+show("a😀b".replace("", "-"));
+`;
+        expectSameOutputAsNode(source, { name: "utf16_iteration_json" });
+    });
+    it("reports RegExp offsets in UTF-16 code units", () => {
+        const source = `
+const show = (v: unknown) => console.log(JSON.stringify(v));
+show("中😀x1".match(/1/)!.index);
+show("中😀x".search(/x/));
+show("中1".replace(/1/, (m: string, at: number) => String(at)));
+show("a1b2".replace(/\\d/g, (m: string, at: number) => String(at)));
+show("中1".replace(/1/, "#"));
+show(JSON.stringify("中😀中".split(/😀/)));
+`;
+        expectSameOutputAsNode(source, { name: "utf16_regex_offsets" });
+    });
+    it("normalizes surrogate pairs across lazy concatenation boundaries", () => {
+        const source = `
+const prefix = "x".repeat(40);
+const high = "\\uD83D";
+const low = "\\uDE00";
+const s = prefix + high + low;
+const show = (v: unknown) => console.log(JSON.stringify(v));
+show(s.length);
+show(s.slice(-2));
+show(s === prefix + "😀");
+show(s.charCodeAt(40));
+show(s.charCodeAt(41));
+show(s.codePointAt(40));
+show(s.endsWith("😀"));
+show(s.indexOf("😀"));
+`;
+        expectSameOutputAsNode(source, { name: "utf16_lazy_boundary" });
+    });
+    it("prints a lone surrogate as the replacement character", () => {
+        expect(runProgram('console.log("😀"[0], "中".length);', { name: "utf16_console" })).toBe("� 1");
+    });
+});
+//# sourceMappingURL=string-utf16.test.js.map

package/dist/tests/e2e/string-utf16.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-utf16.test.js","sourceRoot":"","sources":["../../../tests/e2e/string-utf16.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,WAAW,CAAC,yBAAyB,EAAE,CAAC,OAAO,EAAE,EAAE;IACjD,MAAM,EAAE,UAAU,EAAE,sBAAsB,EAAE,GAAG,OAAO,CAAC;IAEvD,EAAE,CAAC,0DAA0D,EAAE,GAAG,EAAE;QAClE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4ClB,CAAC;QACE,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kEAAkE,EAAE,GAAG,EAAE;QAC1E,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqClB,CAAC;QACE,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,CAAC;IACnE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACrD,MAAM,MAAM,GAAG;;;;;;;;CAQlB,CAAC;QACE,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iEAAiE,EAAE,GAAG,EAAE;QACzE,MAAM,MAAM,GAAG;;;;;;;;;;;;;;CAclB,CAAC;QACE,sBAAsB,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;QAC9D,MAAM,CAAC,UAAU,CAAC,mCAAmC,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACjG,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/tests/helpers.d.ts

@@ -18,9 +18,18 @@ export declare function bindSource(text: string): {
 export declare function compileToIr(text: string, extensions?: ExtensionRegistry, target?: {
     platform: string;
     arch: string;
+}, options?: {
+    readonly debug?: boolean;
 }): {
     ir: string;
     binding: BindResult;
     diagnostics: readonly Diagnostic[];
 };
+/**
+ * True when a *supported* clang is available. The end-to-end suites really
+ * compile and link native binaries, and the emitted IR needs clang >= 16, so a
+ * missing or too-old toolchain skips them instead of failing every case with an
+ * opaque-pointer error. `resolveToolchain` applies the same selection (and
+ * version gate) the driver uses, so the tests and the compiler agree.
+ */
 export declare function hasClang(): boolean;

package/dist/tests/helpers.js

@@ -7,7 +7,8 @@ import { Parser } from "../src/parser/parser.js";
 import { bind } from "../src/binder/binder.js";
 import { generate } from "../src/codegen/llvm.js";
 import { createDefaultRegistry } from "../src/extensions/registry.js";
-import { realRunner } from "../src/driver/toolchain.js";
+import { MINIMUM_CLANG_MAJOR } from "../src/driver/toolchain.js";
+import { resolveToolchain } from "../src/driver/toolchain-provider.js";
 export function lex(text) {
     const source = new SourceFile("test.ts", sourceTextBytes(text));
     const diagnostics = new DiagnosticBag();
@@ -28,7 +29,7 @@ export function bindSource(text) {
     const result = bind(file);
     return { result, diagnostics: bag.diagnostics };
 }
-export function compileToIr(text, extensions, target) {
+export function compileToIr(text, extensions, target, options = {}) {
     const { file, diagnostics: parseDiagnostics } = parse(text);
     const diagnostics = new DiagnosticBag();
     diagnostics.addAll(parseDiagnostics);
@@ -37,10 +38,32 @@ export function compileToIr(text, extensions, target) {
         builtins: registry.builtins(),
         modules: registry.modules(),
         ...(target ? { target } : {}),
+        debug: options.debug === true,
     });
     return { ir, binding, diagnostics: diagnostics.diagnostics };
 }
+let cachedClangSupport;
+/**
+ * True when a *supported* clang is available. The end-to-end suites really
+ * compile and link native binaries, and the emitted IR needs clang >= 16, so a
+ * missing or too-old toolchain skips them instead of failing every case with an
+ * opaque-pointer error. `resolveToolchain` applies the same selection (and
+ * version gate) the driver uses, so the tests and the compiler agree.
+ */
 export function hasClang() {
-    return realRunner.run(process.env.xbintsc_CLANG ?? "clang", ["--version"]).status === 0;
+    if (cachedClangSupport === undefined) {
+        try {
+            const version = resolveToolchain().version;
+            cachedClangSupport = version === undefined || version.major >= MINIMUM_CLANG_MAJOR;
+        }
+        catch {
+            cachedClangSupport = false;
+        }
+        if (!cachedClangSupport) {
+            console.warn(`xbintsc: skipping end-to-end tests — clang ${MINIMUM_CLANG_MAJOR}+ was not found ` +
+                "(see doc/requirements.md, or set xbintsc_CLANG)");
+        }
+    }
+    return cachedClangSupport;
 }
 //# sourceMappingURL=helpers.js.map

package/dist/tests/helpers.js.map

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

package/dist/tests/parser/expressions.test.js

@@ -44,4 +44,11 @@ describe("assignment validation", () => {
         expect(diagnostics.some((d) => d.code === DiagnosticCode.InvalidAssignmentTarget)).toBe(true);
     });
 });
+describe("unsupported syntax", () => {
+    it("reports new.target as an unsupported feature, not a syntax error", () => {
+        const { diagnostics } = parse("function F() { return new.target; }");
+        expect(diagnostics.map((d) => d.code)).toContain(DiagnosticCode.UnsupportedFeature);
+        expect(diagnostics.map((d) => d.code)).not.toContain(DiagnosticCode.UnexpectedToken);
+    });
+});
 //# sourceMappingURL=expressions.test.js.map

package/dist/tests/parser/expressions.test.js.map

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

package/dist/tests/version.test.d.ts

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

package/dist/tests/version.test.js

@@ -0,0 +1,24 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { COMPILER_VERSION } from "../src/driver/compiler.js";
+const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+describe("compiler version", () => {
+    it("matches package.json", () => {
+        expect(COMPILER_VERSION).toBe(packageJson.version);
+    });
+    it("is part of the incremental cache key", () => {
+        const source = readFileSync(new URL("../src/driver/compiler.ts", import.meta.url), "utf8");
+        expect(source).toMatch(/hashParts\(\[\s*COMPILER_VERSION,/);
+    });
+    it("is printed by `xbintsc version`", async () => {
+        const { run } = await import("../src/cli/main.js");
+        const lines = [];
+        const code = run(["version"], {
+            stdout: (text) => lines.push(text),
+            stderr: (text) => lines.push(text),
+        });
+        expect(code).toBe(0);
+        expect(lines.join("")).toContain(COMPILER_VERSION);
+    });
+});
+//# sourceMappingURL=version.test.js.map

package/dist/tests/version.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.test.js","sourceRoot":"","sources":["../../tests/version.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAC5B,YAAY,CAAC,IAAI,GAAG,CAAC,iBAAiB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAC3C,CAAC;AAEzB,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,EAAE,CAAC,sBAAsB,EAAE,GAAG,EAAE;QAC9B,MAAM,CAAC,gBAAgB,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,GAAG,CAAC,2BAA2B,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC3F,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC;IAC9D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,iCAAiC,EAAE,KAAK,IAAI,EAAE;QAC/C,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,MAAM,CAAC,oBAAoB,CAAC,CAAC;QACnD,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,GAAG,CAAC,CAAC,SAAS,CAAC,EAAE;YAC5B,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;YAClC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;SACnC,CAAC,CAAC;QACH,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/doc/DESIGN.md

@@ -41,16 +41,21 @@ xt_value fn(xt_value env, int32_t argc, xt_value *argv);
 
 `env` threads captured variables by reference through boxes, so direct calls and
 closure calls share a single code path. JavaScript semantics that are awkward to
-inline (`+` coercion, relational comparison, property access, inspection) are
-delegated to `@xt_*` runtime calls.
+inline (`+` coercion, property access, inspection) are delegated to `@xt_*`
+runtime calls. Numeric arithmetic and comparison are the exception: codegen emits
+the double fast path inline (`numeric.ts`) and calls the runtime for the coercing
+cases.
 
 ### Runtime
 
-`runtime/xt_runtime.c` implements strings, objects, arrays, closures, arithmetic,
-comparison, exceptions and Node-like `console.log` inspection. It uses a
-non-moving mark-sweep collector behind `xt_alloc` (explicit roots, subsystem
-root providers and a conservative C-stack scan), so the collector's internals
-stay isolated from the compiler.
+`runtime/` implements strings, objects, arrays, closures, arithmetic, comparison,
+exceptions and Node-like `console.log` inspection. It is split by concern into
+translation units (`xt_values.c`, `xt_containers.c`, `xt_stdlib.c`,
+`xt_builtins.c`, `xt_io.c`, `xt_alloc.c`, …), each `#include`-ing its
+implementation fragments (`.inc`) so files stay small without changing the link
+surface. It uses a non-moving mark-sweep collector behind `xt_alloc` (explicit
+roots, subsystem root providers and a conservative C-stack scan), so the
+collector's internals stay isolated from the compiler.
 
 ### Replacing llc
 
@@ -103,15 +108,18 @@ found on `PATH` (the MSVC ABI when LLVM + the Visual Studio C++ build tools are
 installed), and each manifest declares any platform-specific linker flags. See
 `examples/extensions/` and `runtime/xt_ext.h` / `runtime/xt_ext.rs`.
 
-## Self-hosting roadmap
+## Self-hosting
 
-The compiler itself is written in TypeScript and emits IR text, and `runtime` is
-already decoupled from the compiler. Later, the runtime can be rewritten in TS
-and the compiler can compile itself, gradually reaching self-hosting.
+The compiler compiles itself: `xbintsc build src/cli/main.ts --ext node` produces
+a working `xbintsc` binary, and the emitted IR is a fixpoint from the first
+generation onward. CI builds those binaries for every supported platform and
+checks the fixpoint. The runtime stays in C; rewriting it in TypeScript is an
+option for later, not a prerequisite for self-hosting.
 
 ## Tests
 
 Organised by module: `tests/lexer`, `tests/parser`, `tests/binder`,
 `tests/codegen`, `tests/driver`, `tests/extensions`, `tests/cli`, `tests/e2e`.
-When `clang` is present, e2e tests really compile and run binaries; otherwise
+When a supported clang (16+, the same version gate `build` applies) is present,
+e2e tests really compile and run binaries; otherwise
 they are skipped automatically.

package/doc/ai/cli.md

@@ -36,6 +36,8 @@ unknown command prints an error plus the help text and exits 1.
     --app-id <id>     macOS bundle identifier (e.g. com.example.demo)
     --force           Ignore the incremental cache
     --verbose         Print progress information
+    --time            Print per-phase build timings
+    --debug           Emit debug info (DWARF/CodeView) and keep frame pointers
 ```
 
 Parsing details that occasionally surprise:

package/doc/ai/contributing.md

@@ -38,6 +38,7 @@ it. Release tags are created by `release.yml`, never by the hook.
 | `npm run test:watch` | vitest in watch mode |
 | `npm run coverage` | V8 coverage of the TypeScript compiler (`src/`) |
 | `npm run coverage:runtime` | LLVM coverage of the C runtime (`runtime/`) |
+| `npm run bench` | build and time the fixed benchmark suite (optionally vs Node) |
 
 Unit tests live one directory per module under `tests/` (`lexer`, `parser`,
 `binder`, `codegen`, `driver`, `extensions`, `cli`, `e2e`) and mirror the source
@@ -75,13 +76,15 @@ nondeterminism (a `Map`/`Set` iteration over insertion-ordered data you did not
 control, a timestamp, a filesystem-order dependency) into codegen.
 
 A second consequence is the string model: the compiler's own source text has to
-mean the same thing in every generation. A compiled string is UTF-8 bytes, so the
-self-hosted `readFileSync` (`--ext node`) hands the scanner the bytes of a file,
-while Node hands it the same file already decoded — read source files through
-`decodeUtf8` ([src/diagnostics/utf8.ts](../../src/diagnostics/utf8.ts)) and never
-assume a code unit is a byte or a character. Getting this wrong shows up as a
-non-ASCII literal (`—` in a hint string) coming out re-encoded in `gen2.ll`, which
-is why the emitted IR is compared byte-for-byte rather than line-by-line.
+mean the same thing in every generation. A compiled string stores UTF-8 bytes
+but indexes them in UTF-16 code units, so the self-hosted `readFileSync`
+(`--ext node`) hands the scanner a byte string (one byte per code unit, all
+`<= 0xFF`), while Node hands it the same file already decoded — read source
+files through `decodeUtf8` ([src/diagnostics/utf8.ts](../../src/diagnostics/utf8.ts))
+and never assume a code unit is a byte or a character. Getting this wrong shows
+up as a non-ASCII literal (`—` in a hint string) coming out re-encoded in
+`gen2.ll`, which is why the emitted IR is compared byte-for-byte rather than
+line-by-line.
 
 Verify locally:
 
@@ -103,7 +106,12 @@ diff scratch/ref.ll scratch/gen2.ll
   in [../../src/codegen/values.ts](../../src/codegen/values.ts) and
   [../../runtime/rt.h](../../runtime/rt.h); change both together or not at all.
 - Awkward JS semantics (`+` coercion, relational comparison, property access,
-  inspection) are delegated to `@xt_*` runtime calls rather than inlined.
+  inspection) are delegated to `@xt_*` runtime calls. Numeric arithmetic and
+  comparison are the exception: codegen inlines the two-double fast path
+  (`src/codegen/generator/numeric.ts`) and calls the runtime for everything else.
+- String literals are interned: each distinct literal is materialised once in
+  `main`, stored in a GC-rooted global, and loaded at each use. Property names
+  therefore never allocate per access.
 - The GC is a non-moving mark-sweep collector: new heap objects go through
   `xt_alloc`, and a value must be reachable from an explicit root slot, a
   registered root provider (the event loop, the microtask queue) or the

package/doc/ai/extensions.md

@@ -54,8 +54,9 @@ Coverage per module (exact functions and options) is in
 [../node-unimplemented.md](../node-unimplemented.md).
 
 Remember the runtime model before building on `net`/`http`: the event loop runs
-**after** the program body, and `async`/`await` is a synchronous microtask
-model. See [language-support.md](./language-support.md).
+**after** the program body, but `async`/`await` now suspends on pending promises,
+so a promise settled from a socket callback can be awaited. See
+[language-support.md](./language-support.md).
 
 ### `gui` — HTML/CSS window
 

package/doc/ai/language-support.md

@@ -31,7 +31,7 @@ Canonical detail (always current, much longer):
 | `return`, `throw` as expressions' operands | ✅ | |
 | `namespace` / `module` declaration | 🚫 | parse ✓, codegen ✗ |
 | `with`, `debugger` | 🚫 | not supported |
-| Top-level `await` | 🚫 | wrap it in an `async` function |
+| Top-level `await` | ⚠️ | works by blocking on the event loop until the promise settles (it does not yield the module body like an ES module); prefer wrapping it in an `async` function |
 
 ## Expressions and operators
 
@@ -45,8 +45,8 @@ Canonical detail (always current, much longer):
 | Destructuring (bindings, parameters, nested) | ✅ | defaults + rest supported |
 | `delete`, `in`, `instanceof`, `typeof` | ✅ | |
 | Comma operator, `void` | ✅ | |
-| `new.target` | 🚫 | not implemented |
-| `import.meta` | 🚫 | parsed but has no value |
+| `new.target` | 🚫 | parsed, then rejected with a clear `UnsupportedFeature` |
+| `import.meta` | ✅ | `url`, `dirname`, `filename` (resolved from the executable path) |
 | `super` | ⚠️ | single-level inheritance correct; depth > 1 may be inaccurate |
 
 ## Functions, classes, objects
@@ -71,10 +71,11 @@ Canonical detail (always current, much longer):
 
 | Feature | Status | Notes |
 | --- | --- | --- |
-| `async` / `await`, `Promise`, `Promise.all` | ⚠️ | **synchronous microtask model** — `await` on a settled promise continues synchronously |
-| `setTimeout` and callbacks | ⚠️ | the event loop runs **after** the program body, so a promise settled from a timer cannot be awaited |
-| Sockets / servers (`http`, `net`, `dgram`) | ⚠️ | same model: callbacks run on the event loop after the program body |
-| A real async event loop, worker threads | 🚫 | not implemented |
+| `async` / `await`, `Promise`, `Promise.all` | ✅ | real suspension: an `async` body runs on a stackful coroutine, and awaiting a **pending** promise pauses it until the promise settles. Awaiting an already-settled value still continues synchronously |
+| `setTimeout` and callbacks | ✅ | timers run on the core event loop; `await new Promise(r => setTimeout(r, ms))` works |
+| Sockets / servers (`http`, `net`, `dgram`) | ✅ | callbacks run on the event loop and can settle a promise you await (`net` / `http` examples included in the tests) |
+| `fs/promises` | ⚠️ | awaitable, but each call performs its I/O synchronously before settling, so it does not yield while the I/O runs |
+| `async` generators, worker threads | 🚫 | `async function*` is rejected; workers are child processes |
 
 ## Types: parsed, then erased
 
@@ -98,13 +99,14 @@ Implemented: `Math`, `JSON`, `Date`, `RegExp`, `Map`, `Set`, `WeakMap`/`WeakSet`
 `Symbol`, `Error` family, `BigInt`, `Array`/`String`/`Number`/`Object` methods,
 typed arrays, `String.prototype.match`/`split`/`replace` with capture groups,
 immutable array helpers (`toReversed`, `toSorted`, `toSpliced`, `with`), global
-URI functions.
+URI functions, first-class built-in constructors (`const A = Array; new A(...)`,
+`A.isArray`, `x instanceof A`) and `Object.prototype`
+(`Object.getPrototypeOf({}) === Object.prototype`).
 
 | Missing or different | Status |
 | --- | --- |
 | `String.prototype.normalize`, `structuredClone` | 🚫 |
-| `Error.stack` capture | 🚫 (not captured) |
-| `Object.getPrototypeOf({})` | ⚠️ returns `undefined`, not `Object.prototype` |
+| `Error.stack` capture | ⚠️ function-level frames (name/file/line), no columns; generator bodies are omitted |
 | Global RegExp `lastIndex` | ⚠️ `test`/`exec` ignore it for `/g` and `/y` |
 | Sparse array holes, array out-of-bounds | ⚠️ holes are not tracked distinctly; out-of-bounds reads give `undefined` |
 
@@ -122,13 +124,14 @@ See section 3 of [../unimplemented.md](../unimplemented.md) for the full list.
 | `require()` / CommonJS | 🚫 | rejected with a hint to use `import` |
 | Circular dependencies | 🚫 | |
 | Live bindings | ⚠️ | imports and namespace members are snapshots |
-| `import.meta`, `__dirname`, `__filename` | 🚫 | |
+| `__dirname`, `__filename` | 🚫 | use `import.meta.dirname` / `import.meta.filename` |
 
 ## Strings, numbers, memory
 
 | Item | Behaviour |
 | --- | --- |
-| `String.prototype.length` | ⚠️ **UTF-8 bytes**, not UTF-16 units: `"é".length === 1`, `"😀".length === 4`; `codePointAt` differs accordingly |
+| `String.prototype.length` | ✅ UTF-16 code units (`"中文😀".length === 4`); indexing, `slice`, `indexOf`, `split`, `padStart` and `codePointAt` use the same model. Storage stays UTF-8 |
+| RegExp Unicode matching | ⚠️ the engine is byte-oriented: a literal `中` still matches, but `.` and character classes consume one byte per repetition, and `\d`/`\w` stay ASCII. Match offsets (`match.index`, `search`, replacement callbacks) are reported in UTF-16 code units |
 | Number formatting and coercion | ✅ matches Node (`toFixed`, `toPrecision`, hex/octal/binary parsing) |
 | `BigInt` | ✅ implemented |
 | Garbage collection | ✅ non-moving mark-sweep; explicit roots plus a conservative C-stack scan; single-threaded and stop-the-world; no weak references |