@scriptc/compiler 0.0.22 → 0.0.24

package/dist/backend/emission/emit-exprs.js

@@ -287,6 +287,59 @@ function dynPromiseAdapter(E, inner) {
     E.walkerDefs.push(`${sig} { /* checked-dynamic promise exit ${key} */`, `  ScrDyn *sc_d = (ScrDyn *)scr_promise_payload_ref(sc_src);`, `  ${cDecl(inner, "sc_v")} = ${E.dynCheckHelper(inner)}(sc_d, NULL);`, `  scr_dyn_release(sc_d);`, `  if (scr_exc_pending()) {`, `    scr_promise_reject_pending(sc_dst);`, `    return;`, `  }`, `  ${fulfill}`, `}`, ``);
     return sym;
 }
+/** True when evaluating an index/value expression cannot overwrite the bytes
+ * receiver binding. This deliberately small whitelist enables borrowed
+ * receivers in typed-array hot loops while side-effecting/calling shapes
+ * retain the full snapshot ownership required by JS evaluation order. */
+export function isStableBytesOperand(e, receiverLocalId) {
+    switch (e.kind) {
+        case "numLit":
+        case "boolLit":
+        case "varRef":
+        case "incDec":
+            return true;
+        case "assignExpr":
+            // An assignment nested under truthiness/ternary can still produce the
+            // numeric index/value while overwriting the bytes-typed receiver.
+            return e.localId !== receiverLocalId && isStableBytesOperand(e.value, receiverLocalId);
+        case "bin":
+            return (isStableBytesOperand(e.left, receiverLocalId) &&
+                isStableBytesOperand(e.right, receiverLocalId));
+        case "unary":
+        case "toBool":
+            return isStableBytesOperand(e.operand, receiverLocalId);
+        case "logical":
+            return (isStableBytesOperand(e.left, receiverLocalId) &&
+                isStableBytesOperand(e.right, receiverLocalId));
+        case "ternary":
+            return (isStableBytesOperand(e.cond, receiverLocalId) &&
+                isStableBytesOperand(e.then, receiverLocalId) &&
+                isStableBytesOperand(e.else_, receiverLocalId));
+        case "bytesIntrinsic":
+            return ((e.method === "get" || e.method === "length" || e.method === "byteLength") &&
+                e.receiver.kind === "varRef" &&
+                e.args.every((arg) => isStableBytesOperand(arg, receiverLocalId)));
+        default:
+            return false;
+    }
+}
+/** Evaluate a bytes receiver as a borrow when it is a direct, unboxed
+ * binding and all later operands are stable. The binding's scope/global
+ * owner then keeps the value alive, avoiding retain/release traffic around
+ * every indexed access. Any uncertain shape falls back to an owned temp. */
+export function emitBytesReceiver(E, receiver, following) {
+    if (receiver.kind === "varRef" &&
+        following.every((operand) => isStableBytesOperand(operand, receiver.localId))) {
+        const local = E.currentLocals.get(receiver.localId);
+        if (local && !local.boxed) {
+            return E.newBorrowedTemp(receiver.type, mangleLocal(receiver.localId));
+        }
+        if (!local && E.globalsById.has(receiver.localId)) {
+            return E.newBorrowedTemp(receiver.type, mangleGlobal(receiver.localId));
+        }
+    }
+    return E.emitExpr(receiver);
+}
 export function emitExpr(E, e) {
     switch (e.kind) {
         case "numLit":
@@ -302,6 +355,9 @@ export function emitExpr(E, e) {
             // tag-only); one reaching the generic dispatch escaped its wrap.
             throw new Error(`emitter bug: bare unitLit '${e.unit}'`);
         case "varRef": {
+            const integerLoopIndex = E.integerLoopIndex(e);
+            if (integerLoopIndex !== null)
+                return E.newTemp(e.type, `(double)${integerLoopIndex}`);
             const local = E.currentLocals.get(e.localId);
             if (!local && E.globalsById.has(e.localId)) {
                 const gname = mangleGlobal(e.localId);
@@ -932,7 +988,7 @@ export function emitExpr(E, e) {
                 case "trimEnd":
                     return E.newTemp(e.type, `scr_str_trim_end(${r.name})`);
                 case "split":
-                    return E.newTemp(e.type, `scr_str_split(${r.name}, ${args[0].name})`);
+                    return E.newTemp(e.type, `scr_str_split_limit(${r.name}, ${args[0].name}, ${args[1].name})`);
                 case "padStart":
                     return E.newTemp(e.type, `scr_str_pad_start(${r.name}, ${args[0].name}, ${args[1].name})`);
                 case "padEnd":
@@ -1035,7 +1091,7 @@ export function emitExpr(E, e) {
                 case "replaceAll":
                     return E.fallibleTemp(e.type, `scr_regex_replace_all(${r.name}, ${args[0].name}, ${args[1].name})`);
                 case "split":
-                    return E.fallibleTemp(e.type, `scr_regex_split(${r.name}, ${args[0].name})`);
+                    return E.fallibleTemp(e.type, `scr_regex_split_limit(${r.name}, ${args[0].name}, ${args[1].name})`);
                 default: {
                     const _exhaustive = method;
                     void _exhaustive;
@@ -1152,6 +1208,25 @@ export function emitExpr(E, e) {
                     E.line(`}`);
                     return E.newTemp(e.type, `scr_arr_len(${r.name})`);
                 }
+                case "unshift": {
+                    // Like push, every argument evaluates before mutation. Apply
+                    // them from right to left so their final front order remains
+                    // the source order. Ref ownership moves into the array.
+                    const vs = e.args.map((a) => E.emitExpr(a));
+                    if (acc === "ref")
+                        vs.forEach((v) => E.moveTemp(v));
+                    let last;
+                    for (let i = vs.length - 1; i >= 0; i--) {
+                        last = E.newTemp(e.type, `scr_arr_unshift_${acc}(${r.name}, ${vs[i].name})`);
+                    }
+                    return last ?? E.newTemp(e.type, `scr_arr_len(${r.name})`);
+                }
+                case "unshiftSpread": {
+                    // The runtime snapshots and retains the borrowed source,
+                    // including the aliasing `a.unshift(...a)` case.
+                    const src = E.emitExpr(e.args[0]);
+                    return E.newTemp(e.type, `scr_arr_unshift_spread(${r.name}, ${src.name})`);
+                }
                 case "pop":
                     // Ownership of a refcounted element moves OUT of the array to
                     // this temp (+1 to us, the runtime does not release it).
@@ -1188,6 +1263,10 @@ export function emitExpr(E, e) {
                 }
                 case "toReversed":
                     return E.newTemp(e.type, `scr_arr_to_reversed(${r.name})`);
+                case "reverse":
+                    // Mutates in place and returns a retained reference to the
+                    // receiver, preserving Array.prototype.reverse identity.
+                    return E.newTemp(e.type, `scr_arr_reverse(${r.name})`);
                 case "toSpliced": {
                     const start = E.emitExpr(e.args[0]);
                     const count = E.emitExpr(e.args[1]);
@@ -1303,17 +1382,27 @@ export function emitExpr(E, e) {
                 E.emitPendingCheck();
                 return t;
             }
-            const r = E.emitExpr(e.receiver);
-            const args = e.args.map((a) => E.emitExpr(a));
             const method = e.method;
+            const directElementAccess = method === "length" || method === "byteLength" || method === "get";
+            const r = directElementAccess
+                ? emitBytesReceiver(E, e.receiver, e.args)
+                : E.emitExpr(e.receiver);
+            const integerIndex = method === "get" ? E.integerLoopIndex(e.args[0]) : null;
+            const args = integerIndex === null ? e.args.map((a) => E.emitExpr(a)) : [];
             switch (method) {
                 case "length":
-                    return E.newTemp(e.type, `scr_bytes_len(${r.name})`);
+                    return E.newTemp(e.type, `(double)${r.name}->len`);
                 case "byteLength":
-                    return E.newTemp(e.type, `scr_bytes_byte_len(${r.name})`);
+                    if (e.receiver.type.kind !== "bytes") {
+                        throw new Error("emitter bug: bytesIntrinsic byteLength on non-bytes");
+                    }
+                    return E.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : "4"})`);
                 case "get":
                     // Any invalid index traps (the array runtime's discipline).
-                    return E.newTemp(e.type, `scr_bytes_get(${r.name}, ${args[0].name})`);
+                    if (e.receiver.type.kind !== "bytes") {
+                        throw new Error("emitter bug: bytesIntrinsic get on non-bytes");
+                    }
+                    return E.newTemp(e.type, `${E.bytesElementHelper("get", e.receiver.type.elem, integerIndex !== null)}(${r.name}, ${integerIndex ?? args[0].name})`);
                 case "slice":
                     // Omitted relative indices default like string slice: start 0,
                     // end +Infinity (math.h is always included). Fresh copy, +1.
@@ -1341,18 +1430,30 @@ export function emitExpr(E, e) {
                     return { name: "", type: e.type };
                 }
                 case "toString":
+                case "toStringVar": {
                     // The encoding arg is always present (the frontend completes
-                    // an omitted one to "utf8"). Never throws; +1 string. Range
-                    // forms: [enc, start] decodes to the buffer's end; [enc,
-                    // start, end] clamps the explicit end (negatives empty,
-                    // Node's slice-then-decode).
+                    // an omitted one to "utf8"). The literal path is already
+                    // canonical and cannot throw; toStringVar validates a runtime
+                    // encoding and may throw ERR_UNKNOWN_ENCODING. Both return a
+                    // +1 string. Range forms: [enc, start] decodes to the buffer's
+                    // end; [enc, start, end] clamps the explicit end (negatives
+                    // empty, Node's slice-then-decode).
+                    const checked = method === "toStringVar";
+                    const stem = checked ? "scr_bytes_to_str_checked" : "scr_bytes_to_str";
+                    let out;
                     if (args.length === 3) {
-                        return E.newTemp(e.type, `scr_bytes_to_str_range(${r.name}, ${args[0].name}, ${args[1].name}, ${args[2].name})`);
+                        out = E.newTemp(e.type, `${stem}_range(${r.name}, ${args[0].name}, ${args[1].name}, ${args[2].name})`);
                     }
-                    if (args.length === 2) {
-                        return E.newTemp(e.type, `scr_bytes_to_str_range(${r.name}, ${args[0].name}, ${args[1].name}, (double)${r.name}->len)`);
+                    else if (args.length === 2) {
+                        out = E.newTemp(e.type, `${stem}_range(${r.name}, ${args[0].name}, ${args[1].name}, (double)${r.name}->len)`);
                     }
-                    return E.newTemp(e.type, `scr_bytes_to_str(${r.name}, ${args[0].name})`);
+                    else {
+                        out = E.newTemp(e.type, `${stem}(${r.name}, ${args[0].name})`);
+                    }
+                    if (checked)
+                        E.emitPendingCheck();
+                    return out;
+                }
                 case "equals":
                     return E.newTemp(e.type, `scr_bytes_equals(${r.name}, ${args[0].name})`);
                 case "compareBuf": {
@@ -2503,6 +2604,7 @@ export function emitExpr(E, e) {
                 const t = e.args[0].type;
                 switch (t.kind) {
                     case "f64":
+                    case "date":
                         E.line(`scr_promise_fulfill_f64(${p.name}, ${v.name});${E.srcComment(e.loc)}`);
                         break;
                     case "bool":
@@ -2588,6 +2690,8 @@ export function emitExpr(E, e) {
                 case "fetch.start":
                     E.usesTimers = true;
                     return finish(`scr_fetch_static(${arg(0)}, ${arg(1)})`);
+                case "fetch.responseNew":
+                    return finish(`scr_fetch_response_new(${arg(0)}, ${arg(1)})`);
                 case "fetch.responseJson":
                     return finish(`scr_fetch_response_json(${arg(0)})`);
                 case "fetch.responseText":
@@ -2604,6 +2708,8 @@ export function emitExpr(E, e) {
                     E.line(`scr_promise_race_add(${result.name}, ${source.name}, &${adapter});${E.srcComment(e.loc)}`);
                     return result;
                 }
+                case "fetch.abortControllerNew":
+                    return finish(`scr_fetch_abort_controller_new()`);
                 case "fetch.abortTimeout":
                     E.usesTimers = true;
                     return finish(`scr_fetch_abort_timeout(${arg(0)})`);
@@ -3157,6 +3263,10 @@ export function emitExpr(E, e) {
                     E.line(`scr_qs_parse_into(${dict.name}->${OVERFLOW_MEMBER}, ${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${strTag}, ${arrTag});${E.srcComment(e.loc)}`);
                     return dict;
                 }
+                // node:util.parseArgs (scr_util.c): checked-dynamic config in,
+                // checked-dynamic result out; may throw a coded TypeError.
+                case "util.parseArgs":
+                    return finish(`scr_util_parse_args(${arg(0)})`);
                 // Stats (scr_lib.c): statSync throws like the other sync fs
                 // calls; the getters are pure reads.
                 case "fs.openSync":
@@ -3164,7 +3274,11 @@ export function emitExpr(E, e) {
                     // comes back as f64.
                     return finish(`scr_fs_open(${arg(0)}, ${arg(1)})`);
                 case "fs.readSync":
-                    return finish(`scr_fs_read_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+                    return finish(`scr_fs_read_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
+                case "fs.writeSync":
+                    return finish(`scr_fs_write_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
+                case "fs.writeStrSync":
+                    return finish(`scr_fs_write_str_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
                 case "fs.closeSync":
                     return finish(`scr_fs_close(${arg(0)})`);
                 case "fs.watch":
@@ -3208,6 +3322,12 @@ export function emitExpr(E, e) {
                     return finish(`scr_fs_stat(${arg(0)})`);
                 case "stats.isSymbolicLink":
                     return finish(`scr_stats_is_symlink(${arg(0)})`);
+                case "stats.blocks":
+                    return finish(`scr_stats_blocks(${arg(0)})`);
+                case "stats.nlink":
+                    return finish(`scr_stats_nlink(${arg(0)})`);
+                case "stats.atimeMs":
+                    return finish(`scr_stats_atime_ms(${arg(0)})`);
                 case "stats.mtimeMs":
                     return finish(`scr_stats_mtime_ms(${arg(0)})`);
                 case "stats.isFile":
@@ -4926,6 +5046,20 @@ export function emitExpr(E, e) {
                 case "fs.existsChk":
                     E.usesTimers = true; // the scheduled answer holds the loop open
                     return finish(`scr_fs_exists_async(${arg(0)}, ${arg(1)})`);
+                case "fs.renameCb": {
+                    // The callback MOVES into the scheduled operation. Its
+                    // adapter constructs the program-specific Error | null union
+                    // (or dyn error/null for the JS lane) when the timer fires.
+                    E.usesTimers = true;
+                    const cbT = e.args[2].type;
+                    if (cbT.kind !== "func")
+                        throw new Error("emitter bug: fs.rename callback not a func");
+                    const cb = args[2];
+                    E.moveTemp(cb);
+                    const adapter = E.fsRenameThunkFor(cbT);
+                    E.line(`scr_fs_rename_async(${arg(0)}, ${arg(1)}, ${cb.name}, &${adapter});${E.srcComment(e.loc)}`);
+                    return { name: "", type: e.type };
+                }
                 case "fs.mkdtempChk":
                     return finish(`(scr_fs_mkdtemp_chk(${arg(0)}, ${arg(1)}, ${arg(2)}), ${isRefCounted(e.type) ? `(${cType(e.type).trim()})NULL` : "0"})`);
                 case "fs.mkdtempSyncChk":
@@ -4970,9 +5104,28 @@ export function emitExpr(E, e) {
                 case "zlib.inflateSync":
                     return finish(`scr_zlib_inflate(${arg(0)})`);
                 case "process.stdoutWriteBytes":
-                    return finish(`scr_process_stdout_write_bytes(${arg(0)})`);
+                    return finish(`scr_process_stdout_write_bytes(${arg(0)}, ${arg(1)})`);
                 case "process.stderrWriteBytes":
-                    return finish(`scr_process_stderr_write_bytes(${arg(0)})`);
+                    return finish(`scr_process_stderr_write_bytes(${arg(0)}, ${arg(1)})`);
+                case "process.stdoutWriteBytesCb":
+                case "process.stderrWriteBytesCb": {
+                    // Submit the bytes only after every call argument evaluated,
+                    // then move the completion callback onto the next-tick queue.
+                    // The shared error-first adapter materializes success `null`.
+                    E.usesTimers = true;
+                    const cbT = e.args[2].type;
+                    if (cbT.kind !== "func")
+                        throw new Error("emitter bug: process write callback not a func");
+                    const cb = args[2];
+                    E.moveTemp(cb);
+                    const adapter = E.fsRenameThunkFor(cbT);
+                    const write = e.fn === "process.stdoutWriteBytesCb"
+                        ? "scr_process_stdout_write_bytes"
+                        : "scr_process_stderr_write_bytes";
+                    const out = E.newTemp(e.type, `${write}(${arg(0)}, ${arg(1)})`);
+                    E.line(`scr_process_write_callback(${cb.name}, &${adapter});${E.srcComment(e.loc)}`);
+                    return out;
+                }
                 case "tp.setTimeout":
                     return finish(`scr_tp_set_timeout(${arg(0)})`);
                 case "tp.setImmediate":
@@ -5072,6 +5225,8 @@ export function emitExpr(E, e) {
                     return finish(`scr_fsp_read_file(${arg(0)})`);
                 case "fsp.writeFile":
                     return finish(`scr_fsp_write_file(${arg(0)}, ${arg(1)})`);
+                case "fsp.writeFileMode":
+                    return finish(`scr_fsp_write_file_mode(${arg(0)}, ${arg(1)}, ${arg(2)})`);
                 case "fsp.mkdir":
                     return finish(`scr_fsp_mkdir(${arg(0)})`);
                 case "fsp.mkdirMode":
@@ -5084,12 +5239,51 @@ export function emitExpr(E, e) {
                     return finish(`scr_fsp_unlink(${arg(0)})`);
                 case "fsp.chmod":
                     return finish(`scr_fsp_chmod(${arg(0)}, ${arg(1)})`);
+                case "fsp.rename":
+                    return finish(`scr_fsp_rename(${arg(0)}, ${arg(1)})`);
                 case "fsp.readdir":
                     return finish(`scr_fsp_readdir(${arg(0)})`);
                 case "fsp.rm":
                     return finish(`scr_fsp_rm(${arg(0)})`);
                 case "fsp.stat":
                     return finish(`scr_fsp_stat(${arg(0)})`);
+                case "fsp.open":
+                    return finish(`scr_fsp_open(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "fileHandle.fd":
+                    return finish(`scr_file_handle_fd(${arg(0)})`);
+                case "fileHandle.close":
+                    return finish(`scr_file_handle_close_promise(${arg(0)})`);
+                case "fileHandle.readFile":
+                    return finish(`scr_file_handle_read_file_promise(${arg(0)}, ${arg(1)})`);
+                case "fileHandle.readFileBytes":
+                    return finish(`scr_file_handle_read_file_bytes_promise(${arg(0)}, ${arg(1)})`);
+                case "fileHandle.writeFile":
+                    return finish(`scr_file_handle_write_file_promise(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "fileHandle.writeFileBytes":
+                    return finish(`scr_file_handle_write_file_bytes_promise(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+                case "fileHandle.stat":
+                    return finish(`scr_file_handle_stat_promise(${arg(0)})`);
+                case "fileHandle.read":
+                case "fileHandle.writeBytes":
+                case "fileHandle.writeStr": {
+                    if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
+                        throw new Error(`emitter bug: ${e.fn} result`);
+                    }
+                    const inner = e.type.inner;
+                    const countFn = e.fn === "fileHandle.read"
+                        ? `scr_file_handle_read(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`
+                        : e.fn === "fileHandle.writeBytes"
+                            ? `scr_file_handle_write_bytes(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`
+                            : `scr_file_handle_write_str(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`;
+                    const count = E.newTemp(F64, countFn);
+                    const row = E.newTemp(inner, `${mangleRecordNew(inner.shapeId)}()`);
+                    const countField = e.fn === "fileHandle.read" ? "bytesRead" : "bytesWritten";
+                    E.line(`${row.name}->${mangleField(countField)} = ${count.name};`);
+                    E.line(`${row.name}->${mangleField("buffer")} = ${retainCallC(e.args[1].type, arg(1))};`);
+                    const rc = vAdapters(inner);
+                    E.moveTemp(row); // promise fulfillment owns the result record
+                    return finish(`scr_promise_settled_ref(${row.name}, &${rc.retain}, &${rc.release}, ${E.traceArgC(inner)})`);
+                }
                 case "process.argv":
                     return finish(`scr_process_argv()`);
                 case "process.platform":
@@ -6132,7 +6326,17 @@ export function emitExpr(E, e) {
                 case "date.now":
                     // Node's integer milliseconds since epoch. Never throws.
                     return finish(`scr_date_now()`);
+                case "date.newNow":
+                    return finish(`scr_date_now()`);
+                case "date.newMs":
+                    return finish(`scr_date_new_ms(${arg(0)})`);
+                case "date.newString":
+                    return finish(`scr_date_parse_get_time(${arg(0)})`);
+                case "date.getTime":
+                case "date.valueOf":
+                    return finish(`${arg(0)}`);
                 case "date.toISOString":
+                case "date.toISOStringValue":
                     // +1 string, or Node's "Invalid time value" RangeError
                     // (may-throw seed set).
                     return finish(`scr_date_to_iso(${arg(0)})`);
@@ -6144,10 +6348,47 @@ export function emitExpr(E, e) {
                     // MakeDay/MakeTime/TimeClip over seven completed number
                     // arguments; NaN outside the time range. Never throws.
                     return finish(`scr_date_utc(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)})`);
+                case "date.getFullYear":
+                    return finish(`scr_date_get_full_year(${arg(0)}, false)`);
+                case "date.getUTCFullYear":
+                    return finish(`scr_date_get_full_year(${arg(0)}, true)`);
+                case "date.getMonth":
+                    return finish(`scr_date_get_month(${arg(0)}, false)`);
+                case "date.getUTCMonth":
+                    return finish(`scr_date_get_month(${arg(0)}, true)`);
+                case "date.getDate":
+                    return finish(`scr_date_get_date(${arg(0)}, false)`);
+                case "date.getUTCDate":
+                    return finish(`scr_date_get_date(${arg(0)}, true)`);
+                case "date.getDay":
+                    return finish(`scr_date_get_day(${arg(0)}, false)`);
+                case "date.getUTCDay":
+                    return finish(`scr_date_get_day(${arg(0)}, true)`);
+                case "date.getHours":
+                    return finish(`scr_date_get_hours(${arg(0)}, false)`);
+                case "date.getUTCHours":
+                    return finish(`scr_date_get_hours(${arg(0)}, true)`);
+                case "date.getMinutes":
+                    return finish(`scr_date_get_minutes(${arg(0)}, false)`);
+                case "date.getUTCMinutes":
+                    return finish(`scr_date_get_minutes(${arg(0)}, true)`);
+                case "date.getSeconds":
+                    return finish(`scr_date_get_seconds(${arg(0)}, false)`);
+                case "date.getUTCSeconds":
+                    return finish(`scr_date_get_seconds(${arg(0)}, true)`);
+                case "date.getMilliseconds":
+                case "date.getUTCMilliseconds":
+                    return finish(`scr_date_get_milliseconds(${arg(0)})`);
+                case "date.getTimezoneOffset":
+                    return finish(`scr_date_get_timezone_offset(${arg(0)})`);
                 case "text.decode":
                     // WHATWG utf-8 decode with the leading BOM stripped
                     // (scr_bytes.c). Borrowed bytes; +1 string; never throws.
                     return finish(`scr_text_decode(${arg(0)})`);
+                case "text.decodeLegacy":
+                    // Compile-time-labeled WHATWG legacy decode (scr_bytes.c).
+                    // Borrowed bytes + numeric encoding id; +1 string.
+                    return finish(`scr_text_decode_legacy(${arg(0)}, ${arg(1)})`);
                 // The fs option forms (scr_lib.c) — all in the may-throw seed,
                 // like the rest of sync fs.
                 case "fs.mkdirRecursiveSync":
@@ -6170,6 +6411,8 @@ export function emitExpr(E, e) {
                     return finish(`scr_fs_chown(${arg(0)}, ${arg(1)}, ${arg(2)})`);
                 case "fs.copyFileSync":
                     return finish(`scr_fs_copyfile(${arg(0)}, ${arg(1)})`);
+                case "fs.renameSync":
+                    return finish(`scr_fs_rename(${arg(0)}, ${arg(1)})`);
                 case "fs.lstatSync":
                     return finish(`scr_fs_lstat(${arg(0)})`);
                 case "fs.writeFileModeSync":
@@ -6302,7 +6545,7 @@ export function emitExpr(E, e) {
                 throw new Error("emitter bug: yieldExpr with no operand (frontend fills undefined)");
             const v = E.emitExpr(e.value);
             const yt = e.value.type;
-            if (yt.kind === "f64") {
+            if (yt.kind === "f64" || yt.kind === "date") {
                 E.line(`scr_gen_yield_f64(${v.name});${E.srcComment(e.loc)}`);
             }
             else if (yt.kind === "bool") {
@@ -6319,6 +6562,7 @@ export function emitExpr(E, e) {
                     // fences value-position yields on this channel).
                     return { name: "", type: e.type };
                 case "f64":
+                case "date":
                     return E.newTemp(e.type, `scr_gen_take_in_f64()`);
                 case "bool":
                     return E.newTemp(e.type, `scr_gen_take_in_bool()`);
@@ -6356,7 +6600,7 @@ export function emitExpr(E, e) {
                 }
                 else {
                     const nt = e.arg.type;
-                    sendArg((a) => nt.kind === "f64" ? `scr_gen_in_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
+                    sendArg((a) => nt.kind === "f64" || nt.kind === "date" ? `scr_gen_in_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                         : nt.kind === "bool" ? `scr_gen_in_bool(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                             : `scr_gen_in_ref(${g.name}, ${a.name}, ${vAdapters(nt).release});${E.srcComment(e.loc)}`);
                 }
@@ -6368,7 +6612,7 @@ export function emitExpr(E, e) {
                 }
                 else {
                     const rt = e.arg.type;
-                    sendArg((a) => rt.kind === "f64" ? `scr_gen_ret_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
+                    sendArg((a) => rt.kind === "f64" || rt.kind === "date" ? `scr_gen_ret_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                         : rt.kind === "bool" ? `scr_gen_ret_bool(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                             : `scr_gen_ret_ref(${g.name}, ${a.name}, ${vAdapters(rt).release});${E.srcComment(e.loc)}`);
                 }
@@ -6385,7 +6629,10 @@ export function emitExpr(E, e) {
                 const t = e.arg.type;
                 if (isRefCounted(t))
                     E.moveTemp(a); // the cell takes ownership
-                if (t.kind === "f64") {
+                if (t.kind === "date") {
+                    throw new Error("emitter bug: Date generator throw reached backend");
+                }
+                else if (t.kind === "f64") {
                     E.line(`scr_throw_f64(${a.name});${E.srcComment(e.loc)}`);
                 }
                 else if (t.kind === "bool") {
@@ -6418,6 +6665,7 @@ export function emitExpr(E, e) {
             let read;
             switch (e.type.kind) {
                 case "f64":
+                case "date":
                     read = `scr_await_f64(${pr.name})`;
                     break;
                 case "bool":
@@ -6540,6 +6788,7 @@ export function emitExpr(E, e) {
             let mk;
             switch (inner.kind) {
                 case "f64":
+                case "date":
                     mk = `scr_make_resolve(${p.name}, 0)`;
                     break;
                 case "bool":
@@ -6594,6 +6843,7 @@ export function emitExpr(E, e) {
             let mk;
             switch (inner.kind) {
                 case "f64":
+                case "date":
                     mk = `scr_make_resolve(${p.name}, 0)`;
                     break;
                 case "bool":