@scriptc/compiler 0.1.3 → 0.1.5

package/dist/frontend/lowering/surfaces.js

@@ -276,6 +276,7 @@ export const ARRAY_METHODS = new Set([
     "reduce",
     "reduceRight",
     "indexOf",
+    "lastIndexOf",
     "includes",
     "join",
     "slice",
@@ -330,19 +331,19 @@ export const COMPOUND_ASSIGN_OPS = {
  * parameters) that typecheck but have no lowering — those forms are fenced
  * per site instead of silently dropping arguments. */
 export const STR_METHODS = {
-    charCodeAt: { method: "charCodeAt", result: F64, minArgs: 1, maxArgs: 1 },
-    charAt: { method: "charAt", result: STRING, minArgs: 1, maxArgs: 1 },
-    indexOf: { method: "indexOf", result: F64, minArgs: 1, maxArgs: 2 },
+    charCodeAt: { method: "charCodeAt", result: F64, minArgs: 0, maxArgs: 1 },
+    charAt: { method: "charAt", result: STRING, minArgs: 0, maxArgs: 1 },
+    indexOf: { method: "indexOf", result: F64, minArgs: 0, maxArgs: 2 },
     // includes with a position argument is indexOf's clamp exactly (the
     // spec routes both through StringIndexOf) — the emitter composes
     // scr_str_index_of(...) != -1 for the two-argument form.
-    includes: { method: "includes", result: BOOL, minArgs: 1, maxArgs: 2 },
-    startsWith: { method: "startsWith", result: BOOL, minArgs: 1, maxArgs: 1 },
-    endsWith: { method: "endsWith", result: BOOL, minArgs: 1, maxArgs: 1 },
+    includes: { method: "includes", result: BOOL, minArgs: 0, maxArgs: 2 },
+    startsWith: { method: "startsWith", result: BOOL, minArgs: 0, maxArgs: 2 },
+    endsWith: { method: "endsWith", result: BOOL, minArgs: 0, maxArgs: 2 },
     slice: { method: "slice", result: STRING, minArgs: 0, maxArgs: 2 },
     // substring: slice's clamp-and-swap sibling (negatives clamp to 0
     // instead of counting from the end; start > end swaps).
-    substring: { method: "substring", result: STRING, minArgs: 1, maxArgs: 2 },
+    substring: { method: "substring", result: STRING, minArgs: 0, maxArgs: 2 },
     repeat: { method: "repeat", result: STRING, minArgs: 1, maxArgs: 1 },
     trim: { method: "trim", result: STRING, minArgs: 0, maxArgs: 0 },
     trimStart: { method: "trimStart", result: STRING, minArgs: 0, maxArgs: 0 },
@@ -358,10 +359,9 @@ export const STR_METHODS = {
     // astral halves become U+FFFD (SEMANTICS.md divergence 2, the same
     // substitution the island's boundary marshal applied).
     split: { method: "split", result: arrayOf(STRING), minArgs: 1, maxArgs: 2 },
-    // padStart/padEnd with the fill omitted: Node pads with " " — the
-    // lowering completes the default (lowerStringMethodCall).
-    padStart: { method: "padStart", result: STRING, minArgs: 1, maxArgs: 2 },
-    padEnd: { method: "padEnd", result: STRING, minArgs: 1, maxArgs: 2 },
+    // Padding completes omitted lengths and fill strings in its lowering.
+    padStart: { method: "padStart", result: STRING, minArgs: 0, maxArgs: 2 },
+    padEnd: { method: "padEnd", result: STRING, minArgs: 0, maxArgs: 2 },
     // The lre-backed pair (ECMA Default Case Conversion, final sigma
     // included — scr_regex.c): static now, no island needed; their presence
     // flips the regex LINK switch (moduleUsesRegex).
@@ -383,8 +383,8 @@ export const boundaryOutOfIslandMsg = (typeName) => `using an 'any' value where
     `(an 'any' value can only exit to numbers, strings, booleans, JSON-safe records/arrays/unions, ` +
     `and 'T | undefined' over those)`;
 /** The island-backed surface — standard-library APIs with no static
- * runtime implementation (Math methods/properties beyond the compile-time
- * constants, number/string methods beyond the
+ * runtime implementation (Math methods outside STATIC_MATH_FNS,
+ * number/string methods beyond the
  * intrinsic set, parseFloat, ...). ONE table drives both sides of the
  * gate: under --dynamic each entry lowers to marshal → engine execution →
  * validated exit to the declared return type; without the flag each use
@@ -401,11 +401,10 @@ export const ISLAND_SURFACE = {
     /** `Math.<fn>(...)` lowers to callMethod(globalGet("Math"), fn, args);
      * Math.PI and Math.E are compile-time numeric literals in STATIC_MATH_PROPS;
      * remaining Math properties retain island/fence behavior.
-     * min/max/atan2/hypot/pow are declared with exactly two parameters
-     * (rest/optional parameters aren't representable). */
+     * The entries here handle untabled scalar call shapes where --dynamic is
+     * available; STATIC_MATH_FNS handles the ordinary typed calls first. */
     math: {
-        // floor, min/max (two-arg), and random are STATIC now
-        // (STATIC_MATH_FNS below).
+        // The static table below handles these methods at its admitted arities.
         fns: {
             abs: ISL_N1, acos: ISL_N1, asin: ISL_N1, atan: ISL_N1, atan2: ISL_N2,
             cbrt: ISL_N1, ceil: ISL_N1, cos: ISL_N1, exp: ISL_N1,
@@ -456,16 +455,10 @@ export const STATIC_MATH_PROPS = {
     PI: 3.141592653589793,
     E: 2.718281828459045,
 };
-/** Math members with a STATIC lowering — each is one C call that IS the
- * JS operation, at the tabled arity (floor: libm's floor; min/max: the
- * NaN-poisoning ±0-ordered scalar folds; random: arc4random-backed
- * uniform [0,1) — SEMANTICS.md 62). Checked BEFORE the island table
- * (lowerIslandMethodCall), so the tabled arities compile statically and
- * other arities keep the island/fence story — except min/max, whose
- * variadic spelling lowers at ANY plain arity (the n-ary left fold of
- * the scalar compare; zero arguments answer the fold's ∓Infinity seed);
- * unioned with the island table for the methods-as-values fence
- * (lowerMathProperty). */
+/** Math members with a STATIC lowering. Most use the tabled arity; min/max
+ * accept any plain arity, and hypot accepts any arity including number[]
+ * spreads. Checked before the island table by lowerIslandMethodCall and
+ * included in the methods-as-values fence by lowerMathProperty. */
 export const STATIC_MATH_FNS = {
     floor: { fn: "math.floor", arity: 1 },
     abs: { fn: "math.abs", arity: 1 },
@@ -478,6 +471,22 @@ export const STATIC_MATH_FNS = {
     min: { fn: "math.min", arity: 2 },
     max: { fn: "math.max", arity: 2 },
     random: { fn: "math.random", arity: 0 },
+    sin: { fn: "math.sin", arity: 1 },
+    cos: { fn: "math.cos", arity: 1 },
+    tan: { fn: "math.tan", arity: 1 },
+    asin: { fn: "math.asin", arity: 1 },
+    acos: { fn: "math.acos", arity: 1 },
+    atan: { fn: "math.atan", arity: 1 },
+    cbrt: { fn: "math.cbrt", arity: 1 },
+    sign: { fn: "math.sign", arity: 1 },
+    exp: { fn: "math.exp", arity: 1 },
+    sqrt: { fn: "math.sqrt", arity: 1 },
+    log: { fn: "math.log", arity: 1 },
+    log2: { fn: "math.log2", arity: 1 },
+    log10: { fn: "math.log10", arity: 1 },
+    atan2: { fn: "math.atan2", arity: 2 },
+    pow: { fn: "math.pow", arity: 2 },
+    hypot: { fn: "math.hypotArr", arity: 2 },
 };
 /** Number prototype methods with dedicated STATIC lowering paths. The
  * libCall spellings are also the compiled-graph witnesses used by library
@@ -485,6 +494,13 @@ export const STATIC_MATH_FNS = {
 export const STATIC_NUMBER_METHODS = {
     toFixed: { fns: ["num.toFixed0", "num.toFixed"], minArgs: 0, maxArgs: 1 },
 };
+/** The common first-class shape for builtin functions whose supported
+ * source signature is already exactly the fixed native ABI. Keeping the
+ * opt-in on each table row is deliberate: dispatch sentinels and functions
+ * with call-site validation must provide a real adapter instead. */
+function exactValueParams(...types) {
+    return types.map((type) => ({ mode: "required", type }));
+}
 /** The lowerable surface of the supported node builtin modules, keyed by
  * CANONICAL module name (both "fs" and "node:fs" land on "fs" — see
  * canonicalBuiltinModule). Like STR_METHODS, membership is only half the
@@ -498,36 +514,40 @@ export const STATIC_NUMBER_METHODS = {
  * platform's rules on any host). toNamespacedPath is the posix identity
  * (Node: a non-op on posix systems). */
 const PATH_MODULE_FNS = {
-    join: { fn: "path.join", params: [STRING], result: STRING, variadicPack: true },
-    resolve: { fn: "path.resolve", params: [STRING], result: STRING, variadicPack: true },
-    normalize: { fn: "path.normalize", params: [STRING], result: STRING },
-    dirname: { fn: "path.dirname", params: [STRING], result: STRING },
-    basename: { fn: "path.basename", params: [STRING, STRING], result: STRING, defaults: [""] },
-    extname: { fn: "path.extname", params: [STRING], result: STRING },
-    isAbsolute: { fn: "path.isAbsolute", params: [STRING], result: BOOL },
-    relative: { fn: "path.relative", params: [STRING, STRING], result: STRING },
-    toNamespacedPath: { fn: "path.toNamespacedPath", params: [STRING], result: STRING },
+    join: { fn: "path.join", params: [STRING], result: STRING, variadicPack: true, valueParams: [{ mode: "rest", type: STRING }] },
+    resolve: { fn: "path.resolve", params: [STRING], result: STRING, variadicPack: true, valueParams: [{ mode: "rest", type: STRING }] },
+    normalize: { fn: "path.normalize", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    dirname: { fn: "path.dirname", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    basename: { fn: "path.basename", params: [STRING, STRING], result: STRING, defaults: [""], valueParams: [{ mode: "required", type: STRING }, { mode: "optional", type: STRING, defaultValue: "" }] },
+    extname: { fn: "path.extname", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    isAbsolute: { fn: "path.isAbsolute", params: [STRING], result: BOOL, valueParams: [{ mode: "required", type: STRING }] },
+    relative: { fn: "path.relative", params: [STRING, STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }, { mode: "required", type: STRING }] },
+    toNamespacedPath: { fn: "path.toNamespacedPath", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
 };
 /** The win32 twins (scr_path.c's Node-v24 path.win32 port, byte-for-byte):
  * "path/win32" everywhere, and the bare-module table when the build
  * TARGETS win32 — Node on Windows is path.win32. */
 const PATH_WIN32_MODULE_FNS = {
-    join: { fn: "path.win32Join", params: [STRING], result: STRING, variadicPack: true },
-    resolve: { fn: "path.win32Resolve", params: [STRING], result: STRING, variadicPack: true },
-    normalize: { fn: "path.win32Normalize", params: [STRING], result: STRING },
-    dirname: { fn: "path.win32Dirname", params: [STRING], result: STRING },
-    basename: { fn: "path.win32Basename", params: [STRING, STRING], result: STRING, defaults: [""] },
-    extname: { fn: "path.win32Extname", params: [STRING], result: STRING },
-    isAbsolute: { fn: "path.win32IsAbsolute", params: [STRING], result: BOOL },
-    relative: { fn: "path.win32Relative", params: [STRING, STRING], result: STRING },
-    toNamespacedPath: { fn: "path.win32ToNamespacedPath", params: [STRING], result: STRING },
+    join: { fn: "path.win32Join", params: [STRING], result: STRING, variadicPack: true, valueParams: [{ mode: "rest", type: STRING }] },
+    resolve: { fn: "path.win32Resolve", params: [STRING], result: STRING, variadicPack: true, valueParams: [{ mode: "rest", type: STRING }] },
+    normalize: { fn: "path.win32Normalize", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    dirname: { fn: "path.win32Dirname", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    basename: { fn: "path.win32Basename", params: [STRING, STRING], result: STRING, defaults: [""], valueParams: [{ mode: "required", type: STRING }, { mode: "optional", type: STRING, defaultValue: "" }] },
+    extname: { fn: "path.win32Extname", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+    isAbsolute: { fn: "path.win32IsAbsolute", params: [STRING], result: BOOL, valueParams: [{ mode: "required", type: STRING }] },
+    relative: { fn: "path.win32Relative", params: [STRING, STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }, { mode: "required", type: STRING }] },
+    toNamespacedPath: { fn: "path.win32ToNamespacedPath", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
 };
 export const BUILTIN_MODULE_FNS = {
     fs: {
         readFileSync: { fn: "fs.readFileSync", params: [STRING, STRING], result: STRING },
+        // The exact-API subset is first-class. A fixed native ABI is not enough:
+        // rows whose Node function has behavior-bearing trailing options remain
+        // call-only, or function-width adaptation could silently discard those
+        // options before entering the fixed runtime call.
         writeFileSync: { fn: "fs.writeFileSync", params: [STRING, STRING], result: VOID },
         appendFileSync: { fn: "fs.appendFileSync", params: [STRING, STRING], result: VOID },
-        existsSync: { fn: "fs.existsSync", params: [STRING], result: BOOL },
+        existsSync: { fn: "fs.existsSync", params: [STRING], result: BOOL, valueParams: exactValueParams(STRING) },
         mkdirSync: { fn: "fs.mkdirSync", params: [STRING], result: VOID },
         rmSync: { fn: "fs.rmSync", params: [STRING], result: VOID },
         rmdirSync: { fn: "fs.rmdirSync", params: [STRING], result: VOID },
@@ -537,9 +557,9 @@ export const BUILTIN_MODULE_FNS = {
         // accessSync's omitted mode completes to 0 (F_OK) in the special case
         // in lowerBuiltinModuleCall — string `defaults` can't spell a number.
         accessSync: { fn: "fs.accessSync", params: [STRING, F64], result: VOID },
-        unlinkSync: { fn: "fs.unlinkSync", params: [STRING], result: VOID },
-        chmodSync: { fn: "fs.chmodSync", params: [STRING, F64], result: VOID },
-        chownSync: { fn: "fs.chownSync", params: [STRING, F64, F64], result: VOID },
+        unlinkSync: { fn: "fs.unlinkSync", params: [STRING], result: VOID, valueParams: exactValueParams(STRING) },
+        chmodSync: { fn: "fs.chmodSync", params: [STRING, F64], result: VOID, valueParams: exactValueParams(STRING, F64) },
+        chownSync: { fn: "fs.chownSync", params: [STRING, F64, F64], result: VOID, valueParams: exactValueParams(STRING, F64, F64) },
         // The 2-argument form only: Node's mode flags (COPYFILE_EXCL, ...)
         // land on the arity fence.
         copyFileSync: { fn: "fs.copyFileSync", params: [STRING, STRING], result: VOID },
@@ -548,18 +568,22 @@ export const BUILTIN_MODULE_FNS = {
         // adapter. The row still projects the static surface and routes the
         // dispatch.
         rename: { fn: "fs.renameCb", params: [], result: VOID },
-        renameSync: { fn: "fs.renameSync", params: [STRING, STRING], result: VOID },
+        renameSync: { fn: "fs.renameSync", params: [STRING, STRING], result: VOID, valueParams: exactValueParams(STRING, STRING) },
         // statSync's no-follow sibling; stats.isSymbolicLink answers what the
         // follow-free snapshot saw.
         lstatSync: { fn: "fs.lstatSync", params: [STRING], result: STATS_T },
+        fstatSync: { fn: "fs.fstatSync", params: [F64], result: STATS_T, valueParams: exactValueParams(F64) },
+        fchmodSync: { fn: "fs.fchmodSync", params: [F64, F64], result: VOID, valueParams: exactValueParams(F64, F64) },
+        fsyncSync: { fn: "fs.fsyncSync", params: [F64], result: VOID, valueParams: exactValueParams(F64) },
+        linkSync: { fn: "fs.linkSync", params: [STRING, STRING], result: VOID, valueParams: exactValueParams(STRING, STRING) },
         // realpath(3) — Node's realpathSync (failures spell syscall "lstat",
         // Node's own message shape).
         realpathSync: { fn: "fs.realpathSync", params: [STRING], result: STRING },
         // The fd pair behind spawn's fd-stdio form (the daemon-log idiom:
         // openSync(logPath, "a") → spawn stdio ["ignore", fd, fd] →
-        // closeSync). openSync takes Node's string flags ("r", "w", "a", the
-        // +/x variants — unknown flags throw Node's TypeError text); the
-        // numeric-mode third argument fences by arity.
+        // closeSync). String flags use the established two-argument path;
+        // inline numeric O_* expressions route through openNumericSync, with
+        // an optional creation mode as the third argument.
         openSync: { fn: "fs.openSync", params: [STRING, STRING], result: F64 },
         // The buffer forms (fd, buffer, offset, length[, position]). The
         // lowering completes an omitted or literal-null position to -1 (the
@@ -570,7 +594,7 @@ export const BUILTIN_MODULE_FNS = {
         // overloads lower to separate fixed-width runtime ABIs. As with
         // readSync, -1 is the current-offset sentinel.
         writeSync: { fn: "fs.writeSync", params: [F64, BYTES_U8, F64, F64, F64], result: F64 },
-        closeSync: { fn: "fs.closeSync", params: [F64], result: VOID },
+        closeSync: { fn: "fs.closeSync", params: [F64], result: VOID, valueParams: exactValueParams(F64) },
         // Entirely special-cased (lowerFsWatchCall — the callback needs an
         // adapter per listener shape); this entry only routes the dispatch.
         watch: { fn: "fs.watch", params: [], result: VOID },
@@ -585,9 +609,11 @@ export const BUILTIN_MODULE_FNS = {
         readdir: { fn: "fsp.readdir", params: [STRING], result: { kind: "promise", inner: arrayOf(STRING) } },
         rm: { fn: "fsp.rm", params: [STRING], result: { kind: "promise", inner: VOID } },
         stat: { fn: "fsp.stat", params: [STRING], result: { kind: "promise", inner: STATS_T } },
-        unlink: { fn: "fsp.unlink", params: [STRING], result: { kind: "promise", inner: VOID } },
-        chmod: { fn: "fsp.chmod", params: [STRING, F64], result: { kind: "promise", inner: VOID } },
-        rename: { fn: "fsp.rename", params: [STRING, STRING], result: { kind: "promise", inner: VOID } },
+        realpath: { fn: "fsp.realpath", params: [STRING], result: { kind: "promise", inner: STRING } },
+        lstat: { fn: "fsp.lstat", params: [STRING], result: { kind: "promise", inner: STATS_T } },
+        unlink: { fn: "fsp.unlink", params: [STRING], result: { kind: "promise", inner: VOID }, valueParams: exactValueParams(STRING) },
+        chmod: { fn: "fsp.chmod", params: [STRING, F64], result: { kind: "promise", inner: VOID }, valueParams: exactValueParams(STRING, F64) },
+        rename: { fn: "fsp.rename", params: [STRING, STRING], result: { kind: "promise", inner: VOID }, valueParams: exactValueParams(STRING, STRING) },
         // open's optional flags/mode completion is special-cased in
         // lowerBuiltinModuleCall; this row routes all import spellings and
         // gives coverage the static member.
@@ -605,18 +631,18 @@ export const BUILTIN_MODULE_FNS = {
     "path/win32": PATH_WIN32_MODULE_FNS,
     os: {
         // One platform implementation: os.platform() === process.platform.
-        platform: { fn: "process.platform", params: [], result: STRING },
-        homedir: { fn: "os.homedir", params: [], result: STRING },
-        tmpdir: { fn: "os.tmpdir", params: [], result: STRING },
+        platform: { fn: "process.platform", params: [], result: STRING, valueParams: [] },
+        homedir: { fn: "os.homedir", params: [], result: STRING, valueParams: [] },
+        tmpdir: { fn: "os.tmpdir", params: [], result: STRING, valueParams: [] },
         // uname(2)'s release field — Node's own implementation.
-        release: { fn: "os.release", params: [], result: STRING },
+        release: { fn: "os.release", params: [], result: STRING, valueParams: [] },
         // uname(2)'s sysname field ("Darwin", "Linux", "Windows_NT") — the
         // libFn/runtime pair predates this entry (the portless surface used
         // them); this row makes the MODULE call reach them (test/common's
         // isAIX/isIBMi getters are the canonical callers).
-        type: { fn: "os.type", params: [], result: STRING },
+        type: { fn: "os.type", params: [], result: STRING, valueParams: [] },
         // Total physical memory in bytes — same predating-pair story.
-        totalmem: { fn: "os.totalmem", params: [], result: F64 },
+        totalmem: { fn: "os.totalmem", params: [], result: F64, valueParams: [] },
         // Entirely special-cased (lowerOsNetworkInterfacesCall): the result is
         // the call site's mapped Dict<NetworkInterfaceInfo[]> shape, verified
         // structurally there — this entry only routes the dispatch.
@@ -645,11 +671,25 @@ export const BUILTIN_MODULE_FNS = {
         pbkdf2: { fn: "crypto.pbkdf2Cb", params: [], result: VOID },
     },
     zlib: {
-        // Buffer in, Buffer out, Node's default options; string inputs fence
-        // per site (see the zlib special case in lowerBuiltinModuleCall).
+        // The default-options convenience family is special-cased in
+        // lowerBuiltinModuleCall: string inputs UTF-8 encode, callback forms
+        // carry program-shaped closures, and explicit options fence per site.
         // native-toolchain.ts links libz only when these appear on the IR.
+        deflate: { fn: "zlib.deflateCb", params: [], result: VOID },
         deflateSync: { fn: "zlib.deflateSync", params: [BYTES_U8], result: BYTES_U8 },
+        inflate: { fn: "zlib.inflateCb", params: [], result: VOID },
         inflateSync: { fn: "zlib.inflateSync", params: [BYTES_U8], result: BYTES_U8 },
+        deflateRaw: { fn: "zlib.deflateRawCb", params: [], result: VOID },
+        deflateRawSync: { fn: "zlib.deflateRawSync", params: [BYTES_U8], result: BYTES_U8 },
+        inflateRaw: { fn: "zlib.inflateRawCb", params: [], result: VOID },
+        inflateRawSync: { fn: "zlib.inflateRawSync", params: [BYTES_U8], result: BYTES_U8 },
+        gzip: { fn: "zlib.gzipCb", params: [], result: VOID },
+        gzipSync: { fn: "zlib.gzipSync", params: [BYTES_U8], result: BYTES_U8 },
+        gunzip: { fn: "zlib.gunzipCb", params: [], result: VOID },
+        gunzipSync: { fn: "zlib.gunzipSync", params: [BYTES_U8], result: BYTES_U8 },
+        unzip: { fn: "zlib.unzipCb", params: [], result: VOID },
+        unzipSync: { fn: "zlib.unzipSync", params: [BYTES_U8], result: BYTES_U8 },
+        crc32: { fn: "zlib.crc32", params: [], result: F64 },
     },
     url: {
         // fileURLToPath accepts a URL value OR a string — the call lowering
@@ -661,11 +701,13 @@ export const BUILTIN_MODULE_FNS = {
     child_process: {
         // spawnSync's and spawn's call completions are entirely special-cased
         // (an omitted args list completes to an empty string[]; spawnSync
-        // accepts exactly { encoding: "utf8" } as options, spawn requires
-        // exactly { stdio: "ignore" } — see lowerBuiltinModuleCall); the
+        // accepts its documented literal options, while spawn supports the
+        // stdio/detached/env/cwd/windowsHide/shell subset — see
+        // lowerBuiltinModuleCall); the
         // entries carry the canonical shapes.
         spawnSync: { fn: "cp.spawnSync", params: [STRING, arrayOf(STRING)], result: SPAWNRES_T },
         spawn: { fn: "cp.spawn", params: [STRING, arrayOf(STRING)], result: CHILD_T },
+        fork: { fn: "cp.fork", params: [STRING, arrayOf(STRING)], result: CHILD_T },
         // execFileSync(file, args?, options?) and execSync(command, options?)
         // share the cp.execSync runtime entry (execSync sets the shell flag);
         // both call completions are special-cased in lowerBuiltinModuleCall.
@@ -704,8 +746,8 @@ export const BUILTIN_MODULE_FNS = {
         decode: { fn: "qs.parse", params: [STRING], result: VOID },
         stringify: { fn: "qs.stringify", params: [DYN], result: STRING },
         encode: { fn: "qs.stringify", params: [DYN], result: STRING },
-        escape: { fn: "qs.escape", params: [STRING], result: STRING },
-        unescape: { fn: "qs.unescape", params: [STRING], result: STRING },
+        escape: { fn: "qs.escape", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
+        unescape: { fn: "qs.unescape", params: [STRING], result: STRING, valueParams: [{ mode: "required", type: STRING }] },
     },
     // node:readline: createInterface's options are entirely special-cased
     // (exactly { input: process.stdin, output?: process.stdout } — see
@@ -795,6 +837,7 @@ export const BUILTIN_MODULE_FNS = {
  * thread machinery) and never runs as a cluster worker (cluster forks the
  * node binary itself) — Node's own answers for a directly-run script. */
 export const BUILTIN_MODULE_CONSTS = {
+    http: { maxHeaderSize: 16384 },
     path: { sep: "/", delimiter: ":" },
     "path/posix": { sep: "/", delimiter: ":" },
     "path/win32": { sep: "\\", delimiter: ";" },
@@ -812,6 +855,8 @@ export const BUILTIN_MODULE_CONSTS = {
  * (library/fence-eval.ts) and the attestation-parity test. */
 export const BUILTIN_MODULE_FN_ALIASES = {
     fs: {
+        // Inline numeric O_* flags use a target-neutral runtime entry point.
+        openSync: ["fs.openNumericSync"],
         // The Buffer form (no encoding), the fd forms (readFileSync(fd[,
         // "utf8"])), and the checked-dynamic encoding form.
         readFileSync: ["fs.readFileSyncBuf", "fs.readFileSyncBytes", "fs.readFileSyncDyn", "fs.readFdSync", "fs.readFdSyncBytes"],
@@ -841,6 +886,8 @@ export const BUILTIN_MODULE_FN_ALIASES = {
         readFile: ["fsp.readFileBytes"],
         // The string-data { mode } options form.
         writeFile: ["fsp.writeFileMode"],
+        // The { withFileTypes: true } Dirent form.
+        readdir: ["fsp.readdirTypes"],
     },
     crypto: {
         // The composed randomBytes(n).toString(enc) chain keeps its one-libCall
@@ -866,6 +913,13 @@ export const AMBIENT_SURFACE_FNS = [
         fns: ["date.now"],
         note: "the live clock",
     },
+    {
+        id: "stdlib.date.parse",
+        kind: "stdlib",
+        name: "Date.parse",
+        fns: ["date.parse"],
+        note: "one date string, using the bounded parser shared with new Date(dateString).getTime()",
+    },
     {
         id: "stdlib.date.constructor",
         kind: "stdlib",
@@ -1006,6 +1060,13 @@ export const AMBIENT_SURFACE_FNS = [
         fns: ["process.exit", "process.exiting"],
         note: "process.exit and the process._exiting flag read are one surface",
     },
+    {
+        id: "node-builtin.process.exitCode",
+        kind: "node-builtin",
+        name: "process.exitCode",
+        fns: ["process.setExitCode"],
+        note: "numeric writes in statement position set the implicit exit status; process.exit() reads it",
+    },
     // ── the tls CA store (lowerTlsCaCall / lowerTlsRootCertificates): the
     // host's trust anchors, read and replaced. Dedicated paths, and
     // rootCertificates is a VALUE read with no call form at all, so none of
@@ -1113,7 +1174,7 @@ export function builtinConstLit(value, loc) {
  * Node ships one frozen singleton; each read here mints a fresh string
  * array — a divergence only mutation could observe, and mutating Node's
  * frozen array throws anyway. */
-const NODE_BUILTIN_MODULES_V24 = [
+export const NODE_BUILTIN_MODULES_V24 = [
     "_http_agent", "_http_client", "_http_common", "_http_incoming",
     "_http_outgoing", "_http_server", "_stream_duplex", "_stream_passthrough",
     "_stream_readable", "_stream_transform", "_stream_wrap", "_stream_writable",
@@ -1141,19 +1202,16 @@ export function builtinModulesArrayLit(loc) {
     };
 }
 /** Member-specific hints for RECOGNIZED builtin modules whose member has
- * no lowering. deflateSync/inflateSync lower now (Buffers are real);
- * the rest of the zlib surface points at the lowered pair. */
-const ZLIB_HINT = "deflateSync and inflateSync are the lowered zlib surface";
-/** The loose-equality quartet's shared hint: == coercion has no lowering
- * anywhere in this compiler, and Node itself points at the strict forms. */
-const ASSERT_LOOSE_HINT = "loose == equality has no lowering — the strict forms compare with " +
-    "Object.is/structural equality like Node's assert/strict module, where " +
-    "equal IS strictEqual";
+ * no lowering. The default-options one-shot zlib/deflate-raw/gzip codecs
+ * lower for strings and Buffers; the remaining surface points at them. */
+const ZLIB_HINT = "the default-options deflate/inflate, raw, gzip/gunzip, and unzip sync/callback forms plus crc32 are the lowered zlib surface";
+/** The legacy deep pair remains fenced. The shallow equal/notEqual pair
+ * lowers through the static Abstract Equality kernel in lower-assert. */
+const ASSERT_LOOSE_DEEP_HINT = "legacy deep equality has no lowering yet — deepStrictEqual and " +
+    "notDeepStrictEqual compare structures with Node's modern semantics";
 const ASSERT_MODULE_HINTS = {
-    equal: ASSERT_LOOSE_HINT,
-    notEqual: ASSERT_LOOSE_HINT,
-    deepEqual: ASSERT_LOOSE_HINT,
-    notDeepEqual: ASSERT_LOOSE_HINT,
+    deepEqual: ASSERT_LOOSE_DEEP_HINT,
+    notDeepEqual: ASSERT_LOOSE_DEEP_HINT,
     ifError: "test explicitly instead: assert.strictEqual(err, null) / " +
         "assert.strictEqual(err, undefined)",
     rejects: "await the promise inside assert.throws's callback story instead: " +
@@ -1176,10 +1234,7 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
         AssertionError: ASSERT_MODULE_HINTS["AssertionError"],
     },
     util: {
-        promisify: "the one lowered shape is a const binding over child_process.execFile: " +
-            "const execFileAsync = promisify(execFile), then call execFileAsync directly",
-        // child_process.execFile itself exists to be promisified — the same
-        // story from the other end.
+        promisify: "the lowered shapes are const bindings over child_process.execFile and fs.readFile; call the bound function directly",
     },
     "stream/consumers": {
         arrayBuffer: "no free-standing ArrayBuffer value exists here (typed arrays own their storage) — " +
@@ -1189,17 +1244,15 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
     },
     module: {
         createRequire: "the lowered shape is a const binding over createRequire(import.meta.url) (or __filename) " +
-            "whose require calls take STATIC string literals — builtins, relative .json documents, " +
-            "and installed npm packages (under --dynamic) resolve at build time; " +
+            "whose require calls take STATIC string literals — builtins, project modules (including #imports), " +
+            "relative .json documents, --npm-static packages, and installed npm packages under --dynamic resolve at build time; " +
             "dynamic specifiers cannot exist in a compiled binary's fixed module graph",
-        isBuiltin: "builtinModules.includes(name) answers the same question over the baked list " +
-            "(strip a node: prefix first; the prefix-only builtins appear with it, as node:test)",
-        syncBuiltinESMExports: "a compiled program has no live builtin ESM namespace bindings to synchronize — " +
-            "nothing a compiled surface can mutate makes the call observable; remove it",
+        isBuiltin: "the lowered call checks a string against the baked Node v24 list, including bare/node: aliases and prefix-only builtins",
+        syncBuiltinESMExports: "the direct zero-argument call is a no-op because compiled builtin exports are immutable and cannot become stale",
     },
     child_process: {
-        execFile: "the callback form has no lowering — promisify it: " +
-            "const execFileAsync = promisify(execFile) (from node:util), or use execFileSync",
+        execFile: "the callback forms execFile(file, callback), execFile(file, args, callback), and execFile(file, args, { encoding: 'utf8', maxBuffer: N }, callback) lower; " +
+            "maxBuffer is not enforced by the growing native capture; other options and reached no-callback calls remain fenced, while util.promisify(execFile) retains its wider options slice",
     },
     crypto: {
         ...Object.fromEntries([
@@ -1231,9 +1284,6 @@ export const BUILTIN_MODULE_FENCE_HINTS = {
             "randomBytes, and the createHash chain",
     },
     zlib: {
-        gzipSync: ZLIB_HINT,
-        gunzipSync: ZLIB_HINT,
-        unzipSync: ZLIB_HINT,
         brotliCompressSync: ZLIB_HINT,
         brotliDecompressSync: ZLIB_HINT,
     },
@@ -1546,27 +1596,50 @@ export function stdlibGlobalMember(lowerer, access, name) {
    * nothing. Only the globals with lowered member surfaces alias this
    * way; aliasing, say, `Math` would change nothing (its members lower
    * by receiver too). Returns true when recognized. */
-export function stdlibGlobalAliasDecl(lowerer, nameNode, init) {
-    if (!init || !ts.isIdentifier(nameNode))
-        return false;
+export function stdlibGlobalAliasNameOf(lowerer, init) {
+    if (!init)
+        return null;
+    // CommonJS packages commonly guard Node's always-present globals for
+    // browser bundlers (`let p = process || {}`). In the Node execution
+    // model the left object is unconditionally truthy, so the fallback is
+    // never evaluated and the binding is the same global snapshot as the
+    // direct spelling. Keep this deliberately to `||` with a surfaced
+    // stdlib-global left operand; arbitrary capability probes retain their
+    // runtime value semantics.
+    let aliasExpr = init;
+    while (ts.isParenthesizedExpression(aliasExpr))
+        aliasExpr = aliasExpr.expression;
+    if (ts.isBinaryExpression(aliasExpr) &&
+        aliasExpr.operatorToken.kind === ts.SyntaxKind.BarBarToken &&
+        stdlibGlobalNameOf(lowerer, aliasExpr.left) !== null) {
+        aliasExpr = aliasExpr.left;
+    }
     // `const process = require('node:process')`: Node's process MODULE is
     // the global process object (module.exports === globalThis.process),
     // so the binding aliases the global exactly like `const process =
     // globalThis.process`. Preflight admits exactly this shape
     // (processModuleAliasRequire7); commander's lib/command.js opens with
     // it.
-    const requireSpec = requireSpecOf(init);
+    const requireSpec = requireSpecOf(aliasExpr);
     const name = requireSpec === "process" || requireSpec === "node:process"
         ? "process"
-        : stdlibGlobalNameOf(lowerer, init);
+        : stdlibGlobalNameOf(lowerer, aliasExpr);
     if (name === null)
-        return false;
+        return null;
     // Only alias OBJECT-shaped globals whose members lower by receiver
     // identity (process, console, globalThis itself, and perf_hooks'
     // performance — the mockable-clock idiom snapshots it). Function-valued
     // globals (setTimeout) taken as values are a different story — the
     // ordinary value paths (and their fences) apply.
-    if (name !== "process" && name !== "console" && name !== "globalThis" && name !== "performance")
+    return name === "process" || name === "console" || name === "globalThis" || name === "performance"
+        ? name
+        : null;
+}
+export function stdlibGlobalAliasDecl(lowerer, nameNode, init) {
+    if (!ts.isIdentifier(nameNode))
+        return false;
+    const name = stdlibGlobalAliasNameOf(lowerer, init);
+    if (name === null)
         return false;
     const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
     if (!symbol)