@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/lowering/builtins/filesystem-calls.js

@@ -5,16 +5,16 @@ import { locOf } from "../../program.js";
 import { FS_WRITE_FILE_DOCUMENTED_OPTIONS, fenceOrDropOptionKey, } from "../surfaces.js";
 import { voidizedCallback } from "../lower-server.js";
 import { fsStreamCreateExpr } from "./fs-streams.js";
-import { BYTES_U8, DYN, F64, FILEHANDLE_T, STRING, VOID, arrayOf, funcOf, } from "../../../ir/ir.js";
+import { BYTES_U8, DYN, F64, FILEHANDLE_T, STRING, VOID, arrayOf, funcOf, typeEquals, } from "../../../ir/ir.js";
 import { lowerBuiltinOptionalDefault, optionMember, literalBoolOptions } from "./arguments.js";
 import { lowerFsTimestampValue, lowerFsSyncBufferWindow, lowerStringOrBytesWrite, } from "./filesystem.js";
 export function lowerFsCallbackCall(lowerer, expr, bi, loc) {
-    if (expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering("filesystem callback call with spread arguments", expr);
     const timestamp = ["utimes", "futimes", "lutimes"].includes(bi.member);
     const args = {
         kind: "dynArrLit",
-        elems: expr.arguments.map((arg, index) => timestamp && (index === 1 || index === 2)
+        elems: expr.arguments.nodes.map((arg, index) => timestamp && (index === 1 || index === 2)
             ? lowerFsTimestampValue(lowerer, arg, loc)
             : lowerer.lowerExprExpecting(arg, DYN)),
         type: DYN,
@@ -32,10 +32,10 @@ export function lowerFsLinkOrStatfsCall(lowerer, expr, bi, fn, loc, name) {
     const symbolic = bi.member === "symlinkSync" || bi.member === "symlink";
     const reading = bi.member === "readlinkSync" || bi.member === "readlink";
     const arity = symbolic ? 3 : 2;
-    if (expr.arguments.length > arity || expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length > arity || expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`${name} with this argument shape`, expr);
-    const args = Array.from({ length: arity }, (_, index) => expr.arguments[index]
-        ? lowerer.lowerExprExpecting(expr.arguments[index], DYN)
+    const args = Array.from({ length: arity }, (_, index) => expr.arguments.nodes[index]
+        ? lowerer.lowerExprExpecting(expr.arguments.nodes[index], DYN)
         : dynUndefinedExpr(loc));
     if (reading) {
         const promise = bi.module === "fs/promises";
@@ -69,26 +69,26 @@ export function lowerFsLinkOrStatfsCall(lowerer, expr, bi, fn, loc, name) {
  * as dyn values (an omitted argument is undefined); scr_fs_cp_begin
  * validates them in Node's order. */
 export function lowerFsCpCall(lowerer, expr, fn, loc, name) {
-    if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length > 3 || expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`${name} with this argument shape`, expr);
-    const args = [0, 1, 2].map((index) => expr.arguments[index]
-        ? lowerer.lowerExprExpecting(expr.arguments[index], DYN)
+    const args = [0, 1, 2].map((index) => expr.arguments.nodes[index]
+        ? lowerer.lowerExprExpecting(expr.arguments.nodes[index], DYN)
         : dynUndefinedExpr(loc));
     return { kind: "libCall", fn: fn.fn, args, type: fn.result, loc };
 }
 export function lowerFsTimestampCall(lowerer, expr, fn, loc, name) {
-    if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length > 3 || expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`${name} with this argument shape`, expr);
-    const path = expr.arguments[0]
-        ? lowerer.lowerExprExpecting(expr.arguments[0], DYN)
+    const path = expr.arguments.nodes[0]
+        ? lowerer.lowerExprExpecting(expr.arguments.nodes[0], DYN)
         : dynUndefinedExpr(loc);
     return {
         kind: "libCall",
         fn: fn.fn,
         args: [
             path,
-            lowerFsTimestampValue(lowerer, expr.arguments[1], loc),
-            lowerFsTimestampValue(lowerer, expr.arguments[2], loc),
+            lowerFsTimestampValue(lowerer, expr.arguments.nodes[1], loc),
+            lowerFsTimestampValue(lowerer, expr.arguments.nodes[2], loc),
         ],
         type: fn.result,
         loc,
@@ -97,14 +97,14 @@ export function lowerFsTimestampCall(lowerer, expr, fn, loc, name) {
 export function lowerFsVectorOrTruncateCall(lowerer, expr, bi, fn, loc, name) {
     const vector = bi.member !== "ftruncateSync";
     const required = vector ? 2 : 1;
-    if (expr.arguments.length < required ||
-        expr.arguments.length > required + 1 ||
-        expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length < required ||
+        expr.arguments.nodes.length > required + 1 ||
+        expr.arguments.nodes.some(ts.isSpreadElement))
         lowerer.noLowering(`${name} with this argument shape`, expr);
-    const args = [lowerer.lowerExprExpecting(expr.arguments[0], F64)];
+    const args = [lowerer.lowerExprExpecting(expr.arguments.nodes[0], F64)];
     if (vector)
-        args.push(lowerer.lowerExprExpecting(expr.arguments[1], arrayOf(BYTES_U8)));
-    const optional = expr.arguments[required];
+        args.push(lowerer.lowerExprExpecting(expr.arguments.nodes[1], arrayOf(BYTES_U8)));
+    const optional = expr.arguments.nodes[required];
     args.push(optional
         ? lowerBuiltinOptionalDefault(lowerer, optional, F64, numLit(vector ? -1 : 0, loc), vector)
         : numLit(vector ? -1 : 0, loc));
@@ -114,7 +114,7 @@ export function lowerFsVectorOrTruncateCall(lowerer, expr, bi, fn, loc, name) {
 // O_* bit values differ between Darwin and Linux, so emit a stable mask
 // and let the target runtime select its own native constants.
 export function lowerFsNumericOpenCall(lowerer, expr, loc) {
-    if (expr.arguments.length > 3 || expr.arguments.some(ts.isSpreadElement)) {
+    if (expr.arguments.nodes.length > 3 || expr.arguments.nodes.some(ts.isSpreadElement)) {
         lowerer.noLowering("openSync with numeric flags and this argument shape", expr);
     }
     const bits = {
@@ -151,13 +151,13 @@ export function lowerFsNumericOpenCall(lowerer, expr, loc) {
         }
         return null;
     };
-    const mask = flagsOf(expr.arguments[1]);
+    const mask = flagsOf(expr.arguments.nodes[1]);
     if (mask === null) {
-        lowerer.noLowering("openSync with computed numeric flags", expr.arguments[1], "use an inline bitwise OR of fs.constants.O_RDONLY/O_WRONLY/O_RDWR/O_CREAT/O_EXCL/O_NOFOLLOW/O_NONBLOCK/O_TRUNC/O_APPEND");
+        lowerer.noLowering("openSync with computed numeric flags", expr.arguments.nodes[1], "use an inline bitwise OR of fs.constants.O_RDONLY/O_WRONLY/O_RDWR/O_CREAT/O_EXCL/O_NOFOLLOW/O_NONBLOCK/O_TRUNC/O_APPEND");
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-    const mode = expr.arguments[2]
-        ? lowerer.lowerExprExpecting(expr.arguments[2], F64)
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
+    const mode = expr.arguments.nodes[2]
+        ? lowerer.lowerExprExpecting(expr.arguments.nodes[2], F64)
         : { kind: "numLit", value: 0o666, type: F64, loc };
     return {
         kind: "libCall",
@@ -172,19 +172,19 @@ export function lowerFsNumericOpenCall(lowerer, expr, loc) {
 // the descriptor in a shared FileHandle and settles/rejects exactly
 // like the existing fs/promises operations.
 export function lowerFsPromisesOpenCall(lowerer, expr, loc) {
-    if (expr.arguments.length < 1 ||
-        expr.arguments.length > 3 ||
-        expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`fs.promises.open with ${expr.arguments.length} arguments`, expr, "use open(path[, stringFlags[, numericMode]])");
+    if (expr.arguments.nodes.length < 1 ||
+        expr.arguments.nodes.length > 3 ||
+        expr.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`fs.promises.open with ${expr.arguments.nodes.length} arguments`, expr, "use open(path[, stringFlags[, numericMode]])");
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     const defaultFlags = { kind: "strLit", value: "r", type: STRING, loc };
     const defaultMode = { kind: "numLit", value: 0o666, type: F64, loc };
-    const flags = expr.arguments[1]
-        ? lowerBuiltinOptionalDefault(lowerer, expr.arguments[1], STRING, defaultFlags)
+    const flags = expr.arguments.nodes[1]
+        ? lowerBuiltinOptionalDefault(lowerer, expr.arguments.nodes[1], STRING, defaultFlags)
         : defaultFlags;
-    const mode = expr.arguments[2]
-        ? lowerBuiltinOptionalDefault(lowerer, expr.arguments[2], F64, defaultMode)
+    const mode = expr.arguments.nodes[2]
+        ? lowerBuiltinOptionalDefault(lowerer, expr.arguments.nodes[2], F64, defaultMode)
         : defaultMode;
     return {
         kind: "libCall",
@@ -200,12 +200,12 @@ export function lowerFsPromisesOpenCall(lowerer, expr, loc) {
 // the backends can emit the same union-building adapter used by
 // dns.lookup instead of losing the Error arm through a dyn boundary.
 export function lowerFsRenameCallbackCall(lowerer, expr, loc) {
-    if (expr.arguments.length !== 3 || expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`rename with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, "the supported form is rename(oldPath, newPath, callback)");
+    if (expr.arguments.nodes.length !== 3 || expr.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`rename with ${expr.arguments.nodes.length} argument${expr.arguments.nodes.length === 1 ? "" : "s"}`, expr, "the supported form is rename(oldPath, newPath, callback)");
     }
-    const oldPath = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-    const newPath = lowerer.lowerExprExpecting(expr.arguments[1], STRING);
-    let callback = lowerer.lowerExpr(expr.arguments[2]);
+    const oldPath = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
+    const newPath = lowerer.lowerExprExpecting(expr.arguments.nodes[1], STRING);
+    let callback = lowerer.lowerExpr(expr.arguments.nodes[2]);
     // JS/checkJs callback values may arrive as checked-dynamic callables.
     // Adapt them to the one error-first slot; the runtime passes a dyn
     // Error on failure and null on success through the emitted thunk.
@@ -214,7 +214,7 @@ export function lowerFsRenameCallbackCall(lowerer, expr, loc) {
             kind: "dynCheck",
             value: callback,
             type: funcOf([DYN], VOID),
-            loc: locOf(expr.arguments[2]),
+            loc: locOf(expr.arguments.nodes[2]),
         };
     }
     let callbackOk = callback.type.kind === "func" && callback.type.params.length <= 1;
@@ -238,13 +238,13 @@ export function lowerFsRenameCallbackCall(lowerer, expr, loc) {
         }
     }
     if (!callbackOk) {
-        lowerer.unsupported("SC1090", expr.arguments[2], "fs.rename callbacks must accept at most one Error | null parameter");
+        lowerer.unsupported("SC1090", expr.arguments.nodes[2], "fs.rename callbacks must accept at most one Error | null parameter");
     }
     // TypeScript deliberately permits a value-returning function where a
     // void callback is expected; Node ignores that value. Normalize the
     // closure to the runtime's void callback ABI after validating its
     // error-first parameter shape.
-    callback = voidizedCallback(lowerer, callback, locOf(expr.arguments[2]));
+    callback = voidizedCallback(lowerer, callback, locOf(expr.arguments.nodes[2]));
     return {
         kind: "libCall",
         fn: "fs.renameCb",
@@ -258,16 +258,16 @@ export function lowerFsRenameCallbackCall(lowerer, expr, loc) {
 // sentinel; a numeric position performs offset-preserving I/O.
 export function lowerFsReadSyncCall(lowerer, expr, loc) {
     const supported = "use readSync(fd, buffer), readSync(fd, buffer, { offset?, length?, position? }), or readSync(fd, buffer, offset, length[, position]); bigint positions and non-literal options objects have no lowering";
-    if (expr.arguments.length < 2 ||
-        expr.arguments.length > 5 ||
-        expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`readSync with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, supported);
+    if (expr.arguments.nodes.length < 2 ||
+        expr.arguments.nodes.length > 5 ||
+        expr.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`readSync with ${expr.arguments.nodes.length} argument${expr.arguments.nodes.length === 1 ? "" : "s"}`, expr, supported);
     }
-    if (expr.arguments.length === 2) {
+    if (expr.arguments.nodes.length === 2) {
         return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.readSync", { kind: "options", node: undefined }, supported);
     }
-    if (expr.arguments.length === 3) {
-        const optionsNode = expr.arguments[2];
+    if (expr.arguments.nodes.length === 3) {
+        const optionsNode = expr.arguments.nodes[2];
         let valueNode = optionsNode;
         while (ts.isParenthesizedExpression(valueNode))
             valueNode = valueNode.expression;
@@ -277,12 +277,12 @@ export function lowerFsReadSyncCall(lowerer, expr, loc) {
         lowerer.noLowering("readSync with a non-literal options argument", optionsNode, supported);
     }
     const args = [
-        lowerer.lowerExprExpecting(expr.arguments[0], F64),
-        lowerer.lowerExprExpecting(expr.arguments[1], BYTES_U8),
-        lowerer.lowerExprExpecting(expr.arguments[2], F64),
-        lowerer.lowerExprExpecting(expr.arguments[3], F64),
+        lowerer.lowerExprExpecting(expr.arguments.nodes[0], F64),
+        lowerer.lowerExprExpecting(expr.arguments.nodes[1], BYTES_U8),
+        lowerer.lowerExprExpecting(expr.arguments.nodes[2], F64),
+        lowerer.lowerExprExpecting(expr.arguments.nodes[3], F64),
     ];
-    const positionNode = expr.arguments[4];
+    const positionNode = expr.arguments.nodes[4];
     let positionValueNode = positionNode;
     while (positionValueNode && ts.isParenthesizedExpression(positionValueNode)) {
         positionValueNode = positionValueNode.expression;
@@ -306,10 +306,10 @@ export function lowerFsReadSyncCall(lowerer, expr, loc) {
 // runtime, where Node normalizes them to the current descriptor offset.
 export function lowerFsWriteSyncCall(lowerer, expr, loc) {
     const supported = 'use writeSync(fd, buffer[, offset[, length[, position]]]), writeSync(fd, buffer, { offset?, length?, position? }), or writeSync(fd, string[, position[, "utf8"]]); non-literal options objects, bigint positions, and other encodings have no lowering';
-    if (expr.arguments.some(ts.isSpreadElement) || expr.arguments.length < 2) {
-        lowerer.noLowering(`writeSync with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, supported);
+    if (expr.arguments.nodes.some(ts.isSpreadElement) || expr.arguments.nodes.length < 2) {
+        lowerer.noLowering(`writeSync with ${expr.arguments.nodes.length} argument${expr.arguments.nodes.length === 1 ? "" : "s"}`, expr, supported);
     }
-    const dataNode = expr.arguments[1];
+    const dataNode = expr.arguments.nodes[1];
     const dataType = lowerer.mapTypeOf(lowerer.typeOf(dataNode));
     const position = (node) => {
         let valueNode = node;
@@ -328,11 +328,11 @@ export function lowerFsWriteSyncCall(lowerer, expr, loc) {
         if (dataType.elem !== "u8") {
             lowerer.noLowering(`writeSync of '${lowerer.fmt(dataType)}' data`, dataNode, "byte writes take Uint8Array/Buffer data");
         }
-        if (expr.arguments.length === 2) {
+        if (expr.arguments.nodes.length === 2) {
             return lowerFsSyncBufferWindow(lowerer, expr, loc, "fs.writeSync", { kind: "options", node: undefined }, supported);
         }
-        if (expr.arguments.length === 3) {
-            const thirdNode = expr.arguments[2];
+        if (expr.arguments.nodes.length === 3) {
+            const thirdNode = expr.arguments.nodes[2];
             let valueNode = thirdNode;
             while (ts.isParenthesizedExpression(valueNode))
                 valueNode = valueNode.expression;
@@ -344,29 +344,29 @@ export function lowerFsWriteSyncCall(lowerer, expr, loc) {
             }
             lowerer.noLowering("writeSync of Buffer data with a non-numeric offset", thirdNode, supported);
         }
-        if (expr.arguments.length !== 4 && expr.arguments.length !== 5) {
-            lowerer.noLowering(`writeSync of Buffer data with ${expr.arguments.length} arguments`, expr, supported);
+        if (expr.arguments.nodes.length !== 4 && expr.arguments.nodes.length !== 5) {
+            lowerer.noLowering(`writeSync of Buffer data with ${expr.arguments.nodes.length} arguments`, expr, supported);
         }
-        const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
+        const fd = lowerer.lowerExprExpecting(expr.arguments.nodes[0], F64);
         return {
             kind: "libCall",
             fn: "fs.writeSync",
             args: [
                 fd,
                 lowerer.lowerExprExpecting(dataNode, BYTES_U8),
-                lowerer.lowerExprExpecting(expr.arguments[2], F64),
-                lowerer.lowerExprExpecting(expr.arguments[3], F64),
-                position(expr.arguments[4]),
+                lowerer.lowerExprExpecting(expr.arguments.nodes[2], F64),
+                lowerer.lowerExprExpecting(expr.arguments.nodes[3], F64),
+                position(expr.arguments.nodes[4]),
             ],
             type: F64,
             loc,
         };
     }
     if (dataType?.kind === "string") {
-        if (expr.arguments.length > 4) {
-            lowerer.noLowering(`writeSync of string data with ${expr.arguments.length} arguments`, expr, supported);
+        if (expr.arguments.nodes.length > 4) {
+            lowerer.noLowering(`writeSync of string data with ${expr.arguments.nodes.length} arguments`, expr, supported);
         }
-        const encNode = expr.arguments[3];
+        const encNode = expr.arguments.nodes[3];
         let enc = { kind: "strLit", value: "utf8", type: STRING, loc };
         if (encNode !== undefined) {
             const encType = lowerer.typeOf(encNode);
@@ -379,11 +379,16 @@ export function lowerFsWriteSyncCall(lowerer, expr, loc) {
             // a call/getter whose type is the accepted literal cannot vanish.
             enc = lowerer.lowerExprExpecting(encNode, STRING);
         }
-        const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
+        const fd = lowerer.lowerExprExpecting(expr.arguments.nodes[0], F64);
         return {
             kind: "libCall",
             fn: "fs.writeStrSync",
-            args: [fd, lowerer.lowerExprExpecting(dataNode, STRING), position(expr.arguments[2]), enc],
+            args: [
+                fd,
+                lowerer.lowerExprExpecting(dataNode, STRING),
+                position(expr.arguments.nodes[2]),
+                enc,
+            ],
             type: F64,
             loc,
         };
@@ -396,24 +401,31 @@ export function lowerFsWriteSyncCall(lowerer, expr, loc) {
 // like fileURLToPath. Encoding-bearing reads use the shared decoder above;
 // this fallback retains the existing Buffer and utf8 forms.
 export function lowerFsReadDescriptorCall(lowerer, expr, loc) {
-    const fd = lowerer.lowerExprExpecting(expr.arguments[0], F64);
-    if (expr.arguments.length === 1) {
+    const fd = lowerer.lowerExprExpecting(expr.arguments.nodes[0], F64);
+    if (expr.arguments.nodes.length === 1) {
         return { kind: "libCall", fn: "fs.readFdSyncBytes", args: [fd], type: BYTES_U8, loc };
     }
-    const encT = lowerer.typeOf(expr.arguments[1]);
-    if (expr.arguments.length !== 2 ||
+    const encT = lowerer.typeOf(expr.arguments.nodes[1]);
+    if (expr.arguments.nodes.length !== 2 ||
         !(encT.isStringLiteralType() && (encT.value === "utf8" || encT.value === "utf-8"))) {
-        lowerer.noLowering(`readFileSync(fd) with a non-"utf8" encoding`, expr.arguments[1] ?? expr, 'only utf8 reads are supported: readFileSync(fd, "utf8")');
+        lowerer.noLowering(`readFileSync(fd) with a non-"utf8" encoding`, expr.arguments.nodes[1] ?? expr, 'only utf8 reads are supported: readFileSync(fd, "utf8")');
     }
-    const enc = lowerer.lowerExprExpecting(expr.arguments[1], STRING);
+    const enc = lowerer.lowerExprExpecting(expr.arguments.nodes[1], STRING);
     return { kind: "libCall", fn: "fs.readFdSync", args: [fd, enc], type: STRING, loc };
 }
+/** The `{ encoding }` options record. A literal whose value is checked-
+ * dynamic (an encoding variable reassigned from an untyped source) lowers
+ * to a dynamic object: check it into the record the checker describes. */
+function encodingOptions(lowerer, options, type) {
+    const value = lowerer.lowerExpr(options);
+    return typeEquals(value.type, type) ? value : lowerer.coerceInto(options, value, type);
+}
 /** Encoding-bearing reads share Buffer's decoder and runtime alias checks.
  * Keep the read and encoding evaluation in source order in one helper. */
 export function lowerFsEncodedRead(lowerer, expr, descriptor, loc) {
-    if (expr.arguments.length !== 2 || expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length !== 2 || expr.arguments.nodes.some(ts.isSpreadElement))
         return null;
-    const options = expr.arguments[1];
+    const options = expr.arguments.nodes[1];
     const optionsType = lowerer.mapTypeOf(lowerer.typeOf(options));
     if (optionsType?.kind !== "string" && optionsType?.kind !== "record")
         return null;
@@ -425,12 +437,12 @@ export function lowerFsEncodedRead(lowerer, expr, descriptor, loc) {
             return null;
     }
     const sourceType = descriptor ? F64 : STRING;
-    const source = lowerer.lowerExprExpecting(expr.arguments[0], sourceType);
+    const source = lowerer.lowerExprExpecting(expr.arguments.nodes[0], sourceType);
     const encoding = optionsType.kind === "string"
         ? lowerer.lowerExprExpecting(options, STRING)
         : {
             kind: "recordGet",
-            obj: lowerer.lowerExpr(options),
+            obj: encodingOptions(lowerer, options, optionsType),
             shapeId: optionsType.shapeId,
             field: "encoding",
             type: STRING,
@@ -459,12 +471,12 @@ export function lowerFsEncodedRead(lowerer, expr, descriptor, loc) {
  * Promise<string>: the runtime checks the name and decodes, as
  * readFileSync's encoded read does. Null for other shapes. */
 export function lowerFsPromisesEncodedRead(lowerer, expr, loc) {
-    if (expr.arguments.length !== 2 || expr.arguments.some(ts.isSpreadElement))
+    if (expr.arguments.nodes.length !== 2 || expr.arguments.nodes.some(ts.isSpreadElement))
         return null;
     const result = lowerer.mapTypeOf(lowerer.typeOf(expr));
     if (result?.kind !== "promise" || result.inner.kind !== "string")
         return null;
-    const options = expr.arguments[1];
+    const options = expr.arguments.nodes[1];
     const optionsTsType = lowerer.typeOf(options);
     if (optionsTsType.isStringLiteralType() &&
         (optionsTsType.value === "utf8" || optionsTsType.value === "utf-8"))
@@ -479,12 +491,12 @@ export function lowerFsPromisesEncodedRead(lowerer, expr, loc) {
             fields.some((entry) => entry.name !== "encoding"))
             return null;
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     const encoding = optionsType.kind === "string"
         ? lowerer.lowerExprExpecting(options, STRING)
         : {
             kind: "recordGet",
-            obj: lowerer.lowerExpr(options),
+            obj: encodingOptions(lowerer, options, optionsType),
             shapeId: optionsType.shapeId,
             field: "encoding",
             type: STRING,
@@ -504,19 +516,19 @@ export function lowerFsPromisesEncodedRead(lowerer, expr, loc) {
  * opens, as Node's Dir constructor does; other options (recursive, other
  * encodings) have no lowering. */
 export function lowerFsOpendirCall(lowerer, expr, fn, member, loc) {
-    if (expr.arguments.length < 1 ||
-        expr.arguments.length > 2 ||
-        expr.arguments.some(ts.isSpreadElement)) {
-        lowerer.noLowering(`${member} with ${expr.arguments.length} arguments`, expr);
+    if (expr.arguments.nodes.length < 1 ||
+        expr.arguments.nodes.length > 2 ||
+        expr.arguments.nodes.some(ts.isSpreadElement)) {
+        lowerer.noLowering(`${member} with ${expr.arguments.nodes.length} arguments`, expr);
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     let bufferSize = { kind: "numLit", value: 32, type: F64, loc };
-    const optsNode = expr.arguments[1];
+    const optsNode = expr.arguments.nodes[1];
     if (optsNode && !(ts.isIdentifier(optsNode) && optsNode.text === "undefined")) {
         const fence = () => lowerer.noLowering(`${member} options beyond { bufferSize, encoding: "utf8" }`, optsNode, "pass an object literal with a numeric bufferSize and a utf8 encoding; recursive walks and other encodings have no lowering");
         if (!ts.isObjectLiteralExpression(optsNode))
             fence();
-        for (const property of optsNode.properties) {
+        for (const property of optsNode.properties.nodes) {
             const option = optionMember(property);
             if (!option)
                 fence();
@@ -536,7 +548,7 @@ export function lowerFsOpendirCall(lowerer, expr, fn, member, loc) {
 }
 /** fs.createReadStream / fs.createWriteStream(path[, options]). */
 export function lowerFsStreamCreate(lowerer, expr, member, loc) {
-    return fsStreamCreateExpr(lowerer, expr.arguments, member === "createReadStream", `fs.${member}`, expr, loc);
+    return fsStreamCreateExpr(lowerer, expr.arguments.nodes, member === "createReadStream", `fs.${member}`, expr, loc);
 }
 // mkdirSync(p, options): the lowered options form is a literal
 // `{ recursive?: <boolean literal>, mode?: <number> }` — recursive:
@@ -546,13 +558,13 @@ export function lowerFsStreamCreate(lowerer, expr, member, loc) {
 // first created directory, `string | undefined` under @types/node)
 // has no lowering — statement position only.
 export function lowerFsMkdirSyncCall(lowerer, expr, loc) {
-    const optsNode = expr.arguments[1];
+    const optsNode = expr.arguments.nodes[1];
     const options = parseMkdirOptions(optsNode);
     if (!options) {
         lowerer.noLowering("mkdirSync with an options argument beyond { recursive, mode }", optsNode, "the recursive flag must be a boolean literal and mode a number; other options have no lowering");
     }
     const { recursive, modeNode } = options;
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     const mode = modeNode ? lowerer.lowerExprExpecting(modeNode, F64) : null;
     if (!recursive) {
         return mode
@@ -571,13 +583,13 @@ export function lowerFsMkdirSyncCall(lowerer, expr, loc) {
 // The recursive form's value (`string | undefined`) has no lowering;
 // `await` in statement position is the supported use.
 export function lowerFsPromisesMkdirCall(lowerer, expr, loc) {
-    const optsNode = expr.arguments[1];
+    const optsNode = expr.arguments.nodes[1];
     const options = parseMkdirOptions(optsNode);
     if (!options) {
         lowerer.noLowering("fs.promises.mkdir with an options argument beyond { recursive, mode }", optsNode, "the recursive flag must be a boolean literal and mode a number; other options have no lowering");
     }
     const { recursive, modeNode } = options;
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     const mode = modeNode ? lowerer.lowerExprExpecting(modeNode, F64) : null;
     const type = { kind: "promise", inner: VOID };
     if (!recursive) {
@@ -598,11 +610,11 @@ export function lowerFsPromisesMkdirCall(lowerer, expr, loc) {
 // EBUSY/EMFILE/ENFILE/ENOTEMPTY/EPERM. The retry-free shape keeps the
 // historical rmOptsSync lowering unchanged.
 export function lowerFsRemoveCall(lowerer, expr, loc) {
-    const opts = literalBoolOptions(expr.arguments[1], ["recursive", "force"], ["maxRetries", "retryDelay"]);
+    const opts = literalBoolOptions(expr.arguments.nodes[1], ["recursive", "force"], ["maxRetries", "retryDelay"]);
     if (opts === null) {
-        lowerer.noLowering("rmSync with an options argument beyond { recursive, force, maxRetries, retryDelay }", expr.arguments[1], "the recursive/force flags must be boolean literals; maxRetries/retryDelay are numbers; other options have no lowering");
+        lowerer.noLowering("rmSync with an options argument beyond { recursive, force, maxRetries, retryDelay }", expr.arguments.nodes[1], "the recursive/force flags must be boolean literals; maxRetries/retryDelay are numbers; other options have no lowering");
     }
-    const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
+    const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
     const recursive = boolLit(opts.bools["recursive"] === true, loc);
     const force = boolLit(opts.bools["force"] === true, loc);
     if (opts.exprs["maxRetries"] === undefined && opts.exprs["retryDelay"] === undefined) {
@@ -633,7 +645,7 @@ export function lowerFsRemoveCall(lowerer, expr, loc) {
     };
 }
 export function lowerFsWriteBytesCall(lowerer, expr, bi, loc) {
-    const dataIr = lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]));
+    const dataIr = lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]));
     if (dataIr?.kind === "union") {
         const arms = lowerer.unions.get(dataIr.unionId)?.arms;
         if (arms &&
@@ -643,10 +655,10 @@ export function lowerFsWriteBytesCall(lowerer, expr, bi, loc) {
     }
     if (dataIr?.kind === "bytes") {
         if (dataIr.elem !== "u8") {
-            lowerer.noLowering(`${bi.member} of '${lowerer.fmt(dataIr)}' data`, expr.arguments[1], "byte writes take Uint8Array/Buffer data");
+            lowerer.noLowering(`${bi.member} of '${lowerer.fmt(dataIr)}' data`, expr.arguments.nodes[1], "byte writes take Uint8Array/Buffer data");
         }
-        const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-        const data = lowerer.lowerExprExpecting(expr.arguments[1], BYTES_U8);
+        const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
+        const data = lowerer.lowerExprExpecting(expr.arguments.nodes[1], BYTES_U8);
         if (bi.module === "fs/promises") {
             return {
                 kind: "libCall",
@@ -667,7 +679,7 @@ export function lowerFsWriteBytesCall(lowerer, expr, bi, loc) {
     return null;
 }
 export function lowerFsWriteOptionsCall(lowerer, expr, loc, promiseWriteOptions) {
-    const optsNode = expr.arguments[2];
+    const optsNode = expr.arguments.nodes[2];
     const operation = promiseWriteOptions ? "fs.promises.writeFile" : "writeFileSync";
     const plainFn = promiseWriteOptions ? "fsp.writeFile" : "fs.writeFileSync";
     const modeFn = promiseWriteOptions ? "fsp.writeFileMode" : "fs.writeFileModeSync";
@@ -677,8 +689,8 @@ export function lowerFsWriteOptionsCall(lowerer, expr, loc, promiseWriteOptions)
     // values in object-literal order before issuing the write; otherwise a
     // call/getter statically typed as the accepted utf8 literal can vanish.
     const finishWrite = (optionValues) => {
-        const path = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-        const data = lowerer.lowerExprExpecting(expr.arguments[1], STRING);
+        const path = lowerer.lowerExprExpecting(expr.arguments.nodes[0], STRING);
+        const data = lowerer.lowerExprExpecting(expr.arguments.nodes[1], STRING);
         const pathLocal = lowerer.declareHiddenLocal("%writePath", STRING);
         const dataLocal = lowerer.declareHiddenLocal("%writeData", STRING);
         const stmts = [
@@ -723,14 +735,14 @@ export function lowerFsWriteOptionsCall(lowerer, expr, loc, promiseWriteOptions)
         const t = lowerer.typeOf(optsNode);
         if (t.isStringLiteralType() &&
             (t.value === "utf8" || t.value === "utf-8") &&
-            lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind === "string") {
+            lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]))?.kind === "string") {
             return finishWrite([{ kind: "effect", value: lowerer.lowerExprExpecting(optsNode, STRING) }]);
         }
     }
     const optionValues = [];
     let ok = ts.isObjectLiteralExpression(optsNode);
     if (ok) {
-        for (const p of optsNode.properties) {
+        for (const p of optsNode.properties.nodes) {
             const m = optionMember(p);
             if (!m) {
                 ok = false;
@@ -759,7 +771,7 @@ export function lowerFsWriteOptionsCall(lowerer, expr, loc, promiseWriteOptions)
             }
         }
     }
-    if (!ok || lowerer.mapTypeOf(lowerer.typeOf(expr.arguments[1]))?.kind !== "string") {
+    if (!ok || lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]))?.kind !== "string") {
         lowerer.noLowering(`${operation} with 3 arguments`, optsNode, 'the supported options are { mode: <number>, encoding: "utf8" } over string data');
     }
     return finishWrite(optionValues);
@@ -773,19 +785,19 @@ export function lowerFsReadPathCall(lowerer, expr, loc) {
     // non-string paths throw ERR_INVALID_ARG_TYPE where the dynCheck
     // throws its path-annotated TypeError. The fd forms (a number
     // argument) and literal-utf8 reads keep their existing lowerings.
-    const pathV = lowerer.lowerExpr(expr.arguments[0]);
+    const pathV = lowerer.lowerExpr(expr.arguments.nodes[0]);
     if (pathV.type.kind === "string" || pathV.type.kind === "dyn") {
         const pathArg = pathV.type.kind === "dyn" ? { kind: "dynCheck", value: pathV, type: STRING, loc } : pathV;
-        if (expr.arguments.length === 1) {
+        if (expr.arguments.nodes.length === 1) {
             return { kind: "libCall", fn: "fs.readFileSyncBuf", args: [pathArg], type: BYTES_U8, loc };
         }
         // Runtime nullish and empty encodings read Buffers, supported names
         // read strings, and invalid names throw ERR_INVALID_ARG_VALUE. A
         // non-dyn encoding falls through to the literal-utf8 lowering
         // below (the discarded probe IR never emits).
-        const encT = lowerer.typeOf(expr.arguments[1]);
+        const encT = lowerer.typeOf(expr.arguments.nodes[1]);
         if (!(encT.isStringLiteralType() && (encT.value === "utf8" || encT.value === "utf-8"))) {
-            const enc = lowerer.lowerExpr(expr.arguments[1]);
+            const enc = lowerer.lowerExpr(expr.arguments.nodes[1]);
             if (enc.type.kind === "dyn") {
                 return {
                     kind: "libCall",
@@ -805,7 +817,7 @@ function parseMkdirOptions(node) {
         return null;
     let recursive = false;
     let modeNode = null;
-    for (const property of node.properties) {
+    for (const property of node.properties.nodes) {
         const member = optionMember(property);
         if (!member)
             return null;