@scriptc/compiler 0.0.16 → 0.0.18

package/dist/frontend/lowering/lower-containers.js

@@ -5,12 +5,75 @@
 import * as ts from "../ts7/adapter.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, bytesOf, funcOf, isRefCounted, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/nodes.js";
 import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS, STR_METHODS } from "./surfaces.js";
-import { isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
+import { droppableStatic, isRequireMainFilename, lowerDynObjectLiteral, probeLower, pureReemittable } from "./lower-exprs.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { DYN_DISPATCH_METHODS, islandPrimitiveExit } from "./lower-calls.js";
 import { typeKey } from "../types.js";
 import { dynUndefinedExpr, own } from "./lowerer.js";
+/** Lower an expression whose checker type is statically `undefined`/`void`.
+ * Optional builtin arguments use this before their ordinary expected-type
+ * coercion so every equivalent spelling (`undefined`, `void 0`, a typed
+ * binding, or an effectful call returning undefined) selects the default.
+ * An effectful `void e` is exact in this context: evaluate e, then produce
+ * undefined, instead of hitting value-position void's general fence. */
+function lowerStaticallyUndefinedArg(L, node) {
+    const peelErasableWrappers = (value) => {
+        let expr = value;
+        while (ts.isParenthesizedExpression(expr) ||
+            ts.isAsExpression(expr) ||
+            ts.isTypeAssertion(expr) ||
+            ts.isSatisfiesExpression(expr)) {
+            expr = expr.expression;
+        }
+        return expr;
+    };
+    let expr = node;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if ((L.typeOf(expr).flags &
+        (ts.TypeFlags.Undefined | ts.TypeFlags.Void)) ===
+        0) {
+        return null;
+    }
+    // TypeScript erases `as`, angle-bracket assertions, and `satisfies`.
+    // Peel them only for the void recognition: a non-void assertion still
+    // lowers through the ordinary path below, preserving the checked-dynamic
+    // cast discipline. Nested voids add no effects of their own, so the one
+    // innermost operand carries the complete runtime evaluation.
+    expr = peelErasableWrappers(expr);
+    let sawVoid = false;
+    while (ts.isVoidExpression(expr)) {
+        sawVoid = true;
+        expr = peelErasableWrappers(expr.expression);
+    }
+    if (sawVoid) {
+        // The caller discards this token before producing the parameter
+        // default, so the operand itself carries exactly the required effects;
+        // no bare undefined value needs to enter the IR.
+        return L.lowerExpr(expr);
+    }
+    return L.lowerExpr(node);
+}
+/** Preserve a statically-undefined argument's effects, then answer the
+ * optional parameter's already-lowered default value. */
+function defaultAfterUndefined(value, defaultValue) {
+    if (droppableStatic(value))
+        return defaultValue;
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: value, loc: value.loc }],
+        result: defaultValue,
+        type: defaultValue.type,
+        loc: value.loc,
+    };
+}
+function lowerOptionalDefaultArg(L, node, expected, defaultValue) {
+    const undefinedArg = lowerStaticallyUndefinedArg(L, node);
+    return undefinedArg
+        ? defaultAfterUndefined(undefinedArg, defaultValue)
+        : L.lowerExprExpecting(node, expected);
+}
 /** Ambient array method calls. `push`/`pop`/`indexOf`/`includes`/`join`
    * lower to arrIntrinsic; the HOF family — `map`/`filter`/`forEach`/
    * `find`/`some`/`every`/`flatMap`/`reduce`/`reduceRight` — desugars to a
@@ -105,8 +168,72 @@ export function lowerArrayMethodCall(L, call, access) {
             elem = receiver.type.elem;
         }
     }
-    if (name === "sort")
+    if (name === "sort" || name === "toSorted") {
         return lowerArraySortCall(L, call, access, elem, receiverIr);
+    }
+    if (name === "toReversed") {
+        if (call.arguments.length !== 0) {
+            L.noLowering(`.toReversed with ${call.arguments.length} arguments`, call);
+        }
+        return {
+            kind: "arrIntrinsic",
+            method: "toReversed",
+            receiver: L.lowerExpr(access.expression),
+            args: [],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (name === "with") {
+        if (call.arguments.length !== 2 || call.arguments.some(ts.isSpreadElement)) {
+            L.noLowering(`.with with ${call.arguments.length} arguments`, call);
+        }
+        const receiver = L.lowerExpr(access.expression);
+        const index = L.lowerExprExpecting(call.arguments[0], F64);
+        const value = L.coerceInto(call.arguments[1], L.lowerExpr(call.arguments[1]), elem);
+        return {
+            kind: "arrIntrinsic",
+            method: "with",
+            receiver,
+            args: [index, value],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (name === "toSpliced") {
+        if (call.arguments.some(ts.isSpreadElement)) {
+            L.unsupported("SC1090", call, "spread arguments to Array.toSpliced");
+        }
+        const receiver = L.lowerExpr(access.expression);
+        const start = call.arguments[0]
+            ? L.lowerExprExpecting(call.arguments[0], F64)
+            : { kind: "numLit", value: 0, type: F64, loc };
+        const deleteCountDefault = {
+            kind: "numLit",
+            value: NaN,
+            type: F64,
+            loc,
+        };
+        const deleteCount = call.arguments.length === 0
+            ? { kind: "numLit", value: 0, type: F64, loc }
+            : call.arguments[1]
+                ? lowerOptionalDefaultArg(L, call.arguments[1], F64, deleteCountDefault)
+                : { kind: "numLit", value: Infinity, type: F64, loc };
+        const items = {
+            kind: "arrayLit",
+            elems: call.arguments.slice(2).map((arg) => L.coerceInto(arg, L.lowerExpr(arg), elem)),
+            type: receiverIr,
+            loc,
+        };
+        return {
+            kind: "arrIntrinsic",
+            method: "toSpliced",
+            receiver,
+            args: [start, deleteCount, items],
+            type: receiverIr,
+            loc,
+        };
+    }
     // The lib declares wider call forms than the lowered surface —
     // indexOf/includes take a fromIndex, join's separator is optional, the
     // predicate/mapping HOFs take a thisArg. Each unlowered form is fenced
@@ -1287,40 +1414,45 @@ function reduceHelper(L, method, elem, accT, arity, hasInit, loc) {
     L.liftedFns.push({ name, params, returnType: accT, locals, body, loc });
     return name;
 }
-/** `a.sort(cmp)` — in-place, returns the receiver (JS's `this`), desugared
-   * to an interned synthetic function like the other array HOFs. The loop
-   * is a binary-free INSERTION sort: stable (equal-comparing elements keep
-   * their source order, which is what Node's stable TimSort produces for
-   * any consistent comparator) and JS-faithful on the comparator contract —
-   * an element moves left only while cmp(left, v) > 0, so a NaN or 0
-   * result holds position exactly like the spec's "treat as equal". The
-   * SEQUENCE of comparator calls differs from V8's TimSort (SEMANTICS.md);
-   * results are identical for consistent comparators. The comparator-less
-   * form lowers for STRING elements only — JS's default converts every
-   * element to string and compares UTF-16 units, which for strings is the
-   * relational operator the compiler already has (an interned synthesized
-   * comparator); for numbers that default is the notorious string sort
-   * ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
+/** `a.sort(cmp)` / `a.toSorted(cmp)`, desugared to an interned synthetic
+   * function like the other array HOFs. sort mutates and returns the receiver;
+   * toSorted takes its shallow snapshot INSIDE the helper, after the receiver
+   * and comparator expressions have both been evaluated, then sorts and
+   * returns that copy without touching the receiver. The loop is a
+   * binary-free INSERTION sort: stable (equal-comparing elements keep their
+   * source order, which is what Node's stable TimSort produces for any
+   * consistent comparator) and JS-faithful on the comparator contract — an
+   * element moves left only while cmp(left, v) > 0, so a NaN or 0 result holds
+   * position exactly like the spec's "treat as equal". The SEQUENCE of
+   * comparator calls differs from V8's TimSort (SEMANTICS.md); results are
+   * identical for consistent comparators. The comparator-less form lowers for
+   * STRING elements only — JS's default converts every element to string and
+   * compares UTF-16 units, so the interned synthesized comparator selects the
+   * runtime's code-unit ordering rather than scriptc's documented code-point
+   * relational operators. For numbers that default is the notorious string
+   * sort ([10, 9, 1] → [1, 10, 9]), deliberately fenced toward an explicit
    * comparator. */
 export function lowerArraySortCall(L, call, access, elem, arrT) {
     const loc = locOf(call);
+    const method = access.name.text === "toSorted" ? "toSorted" : "sort";
+    const copyFirst = method === "toSorted";
     if (call.arguments.length === 0 && elem.kind === "string") {
         const receiver = L.lowerExpr(access.expression);
         const cmp = defaultStringCmpHelper(L, loc);
         const fnT = funcOf([STRING, STRING], F64);
-        const key = `sort:${typeKey(STRING)}:2`;
+        const key = `${method}:${typeKey(STRING)}:2`;
         let helper = L.arrHofHelpers.get(key);
         if (!helper) {
-            helper = `%arr.sort.${L.arrHofHelpers.size}`;
+            helper = `%arr.${method}.${L.arrHofHelpers.size}`;
             L.arrHofHelpers.set(key, helper);
-            L.liftedFns.push(buildArraySortFn(helper, STRING, 2, loc));
+            L.liftedFns.push(buildArraySortFn(helper, STRING, 2, copyFirst, null, loc));
         }
         const fnArg = { kind: "closure", fnName: cmp, captures: [], type: fnT, loc };
         return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrT, loc };
     }
     if (call.arguments.length !== 1) {
-        L.noLowering(`.sort with ${call.arguments.length} arguments`, call, "the default string-conversion ordering lowers only for string[] — pass a comparator: " +
-            "sort((a, b) => a - b) for numbers");
+        L.noLowering(`.${method} with ${call.arguments.length} arguments`, call, "the default string-conversion ordering lowers only for string[] — pass a comparator: " +
+            `${method}((a, b) => a - b) for numbers`);
     }
     const receiver = L.lowerExpr(access.expression);
     const argNode = call.arguments[0];
@@ -1335,12 +1467,13 @@ export function lowerArraySortCall(L, call, access, elem, arrT) {
         L.badType(argNode, L.typeOf(argNode));
     }
     const arity = fnArg.type.params.length;
-    const key = `sort:${typeKey(elem)}:${arity}`;
+    const key = `${method}:${typeKey(elem)}:${arity}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
-        helper = `%arr.sort.${L.arrHofHelpers.size}`;
+        helper = `%arr.${method}.${L.arrHofHelpers.size}`;
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push(buildArraySortFn(helper, elem, arity, loc));
+        const undefinedTag = elem.kind === "union" ? L.armTag(elem.unionId, UNDEFINED_T) : -1;
+        L.liftedFns.push(buildArraySortFn(helper, elem, arity, copyFirst, undefinedTag >= 0 ? undefinedTag : null, loc));
     }
     return { kind: "call", callee: helper, args: [receiver, fnArg], type: arrT, loc };
 }
@@ -1348,9 +1481,9 @@ export function lowerArraySortCall(L, call, access, elem, arrT) {
    *
    *   (a, b) => a < b ? -1 : a > b ? 1 : 0
    *
-   * For strings, the spec's default (ToString both, compare UTF-16 units)
-   * IS the relational operator, so this synthesized comparator makes
-   * `xs.sort()` exactly `xs.sort((a, b) => ...)`. */
+   * The dedicated UTF-16 comparison flag keeps this exact across
+   * supplementary-plane code points and U+E000..U+FFFF, where the runtime's
+   * ordinary code-point relational order deliberately differs. */
 function defaultStringCmpHelper(L, loc) {
     const key = "sortCmpStr";
     const existing = L.arrHofHelpers.get(key);
@@ -1361,7 +1494,7 @@ function defaultStringCmpHelper(L, loc) {
     const ref = (localId) => ({ kind: "varRef", localId, type: STRING, loc });
     const num = (value) => ({ kind: "numLit", value, type: F64, loc });
     const cmp = (op) => ({
-        kind: "strCmp", op, left: ref("a.0"), right: ref("b.0"), type: BOOL, loc,
+        kind: "strCmp", op, left: ref("a.0"), right: ref("b.0"), utf16: true, type: BOOL, loc,
     });
     const body = [
         {
@@ -1396,16 +1529,18 @@ function defaultStringCmpHelper(L, loc) {
 /** The insertion-sort loop, from existing IR nodes:
    *
    *   n = a.length;
-   *   for (i = 1; i < n; i++) {
-   *     v = a[i]; j = i - 1;
-   *     while (j >= 0) {
-   *       if (f(a[j], v) > 0) { a[j + 1] = a[j]; j = j - 1; } else break;
+    *   for (i = 1; i < n; i++) {
+    *     v = a[i]; j = i - 1;
+    *     while (j >= 0) {
+    *       if (CompareArrayElements(a[j], v, f) > 0) {
+    *         a[j + 1] = a[j]; j = j - 1;
+    *       } else break;
    *     }
    *     a[j + 1] = v;
    *   }
    *   return a;
    */
-function buildArraySortFn(name, elem, arity, loc) {
+function buildArraySortFn(name, elem, arity, copyFirst, undefinedTag, loc) {
     const arrT = arrayOf(elem);
     const fnT = funcOf([elem, elem].slice(0, arity), F64);
     const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
@@ -1413,26 +1548,80 @@ function buildArraySortFn(name, elem, arity, loc) {
     const j = ref("j.0", F64);
     const at = (index) => ({ kind: "arrayGet", arr: ref("a.0", arrT), index, type: elem, loc });
     const jPlus1 = { kind: "bin", op: "+", left: j, right: num(1), type: F64, loc };
+    const isUndefined = (value) => {
+        if (elem.kind === "union" && undefinedTag !== null) {
+            return {
+                kind: "unionIsTag",
+                unionId: elem.unionId,
+                tag: undefinedTag,
+                negated: false,
+                value,
+                type: BOOL,
+                loc,
+            };
+        }
+        if (elem.kind === "jsval") {
+            return {
+                kind: "jsOp",
+                op: "eq",
+                args: [
+                    value,
+                    { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc },
+                ],
+                type: BOOL,
+                loc,
+            };
+        }
+        return null;
+    };
+    const compareGreater = {
+        kind: "bin",
+        op: ">",
+        left: {
+            kind: "callValue",
+            callee: ref("f.0", fnT),
+            args: [at(j), ref("v.0", elem)].slice(0, arity),
+            type: F64,
+            loc,
+        },
+        right: num(0),
+        type: BOOL,
+        loc,
+    };
+    const leftUndefined = isUndefined(at(j));
+    const valueUndefined = isUndefined(ref("v.0", elem));
+    // CompareArrayElements: undefined always sinks and never reaches the
+    // user comparator. Ternaries preserve that callback suppression.
+    const shouldShift = leftUndefined !== null && valueUndefined !== null
+        ? {
+            kind: "ternary",
+            cond: leftUndefined,
+            then: {
+                kind: "unary",
+                op: "!",
+                operand: valueUndefined,
+                type: BOOL,
+                loc,
+            },
+            else_: {
+                kind: "ternary",
+                cond: valueUndefined,
+                then: { kind: "boolLit", value: false, type: BOOL, loc },
+                else_: compareGreater,
+                type: BOOL,
+                loc,
+            },
+            type: BOOL,
+            loc,
+        }
+        : compareGreater;
     const shiftLoop = {
         kind: "while",
         cond: { kind: "bin", op: ">=", left: j, right: num(0), type: BOOL, loc },
         body: [
             {
                 kind: "if",
-                cond: {
-                    kind: "bin",
-                    op: ">",
-                    left: {
-                        kind: "callValue",
-                        callee: ref("f.0", fnT),
-                        args: [at(j), ref("v.0", elem)].slice(0, arity),
-                        type: F64,
-                        loc,
-                    },
-                    right: num(0),
-                    type: BOOL,
-                    loc,
-                },
+                cond: shouldShift,
                 then: [
                     { kind: "arraySet", arr: ref("a.0", arrT), index: jPlus1, value: at(j), loc },
                     { kind: "assign", localId: "j.0", value: { kind: "bin", op: "-", left: j, right: num(1), type: F64, loc }, loc },
@@ -1444,6 +1633,21 @@ function buildArraySortFn(name, elem, arity, loc) {
         loc,
     };
     const body = [
+        ...(copyFirst
+            ? [{
+                    kind: "assign",
+                    localId: "a.0",
+                    value: {
+                        kind: "arrIntrinsic",
+                        method: "slice",
+                        receiver: ref("a.0", arrT),
+                        args: [],
+                        type: arrT,
+                        loc,
+                    },
+                    loc,
+                }]
+            : []),
         readLenStmt(arrT, loc),
         {
             kind: "for",
@@ -1484,6 +1688,294 @@ function buildArraySortFn(name, elem, arity, loc) {
         loc,
     };
 }
+/** Uint8Array.prototype.toSorted. The receiver/comparator expressions are
+ * evaluated before entering the helper; the helper snapshots with
+ * TypedArray.prototype.slice before its first comparison, then performs
+ * the same stable insertion walk as Array.toSorted. Uint8Array's default
+ * comparator is numeric ascending, so its comparator-less form needs no
+ * string-conversion machinery. */
+function lowerBytesToSortedCall(L, call, access, bytesT) {
+    const loc = locOf(call);
+    if (call.arguments.length > 1 || call.arguments.some(ts.isSpreadElement)) {
+        L.noLowering(`.toSorted with ${call.arguments.length} arguments on Uint8Array`, call);
+    }
+    const receiver = L.lowerExpr(access.expression);
+    const undefinedArg = call.arguments[0]
+        ? lowerStaticallyUndefinedArg(L, call.arguments[0])
+        : null;
+    if (call.arguments.length === 0 || undefinedArg) {
+        const key = "bytes.toSorted:u8:default";
+        let helper = L.arrHofHelpers.get(key);
+        if (!helper) {
+            helper = `%bytes.toSorted.${L.arrHofHelpers.size}`;
+            L.arrHofHelpers.set(key, helper);
+            L.liftedFns.push(buildBytesSortFn(helper, 0, false, loc));
+        }
+        if (!undefinedArg || droppableStatic(undefinedArg)) {
+            return { kind: "call", callee: helper, args: [receiver], type: bytesT, loc };
+        }
+        // The default helper takes no comparator argument. Snapshot the
+        // receiver into a hidden local so the discarded undefined argument
+        // still evaluates after the receiver and before the helper call.
+        const saved = L.declareHiddenLocal("%bytesSortRecv", bytesT);
+        const savedRef = {
+            kind: "varRef",
+            localId: saved.id,
+            type: bytesT,
+            loc,
+        };
+        return {
+            kind: "seqExpr",
+            stmts: [
+                { kind: "varDecl", localId: saved.id, init: receiver, loc },
+                { kind: "exprStmt", expr: undefinedArg, loc: undefinedArg.loc },
+            ],
+            result: {
+                kind: "call",
+                callee: helper,
+                args: [savedRef],
+                type: bytesT,
+                loc,
+            },
+            type: bytesT,
+            loc,
+        };
+    }
+    const argNode = call.arguments[0];
+    const fnArg = L.lowerExpr(argNode);
+    if (fnArg.type.kind !== "func" ||
+        fnArg.type.params.length > 2 ||
+        !fnArg.type.params.every((p) => p.kind === "f64") ||
+        fnArg.type.ret.kind !== "f64") {
+        L.badType(argNode, L.typeOf(argNode));
+    }
+    const arity = fnArg.type.params.length;
+    const key = `bytes.toSorted:u8:${arity}`;
+    let helper = L.arrHofHelpers.get(key);
+    if (!helper) {
+        helper = `%bytes.toSorted.${L.arrHofHelpers.size}`;
+        L.arrHofHelpers.set(key, helper);
+        L.liftedFns.push(buildBytesSortFn(helper, arity, true, loc));
+    }
+    return {
+        kind: "call",
+        callee: helper,
+        args: [receiver, fnArg],
+        type: bytesT,
+        loc,
+    };
+}
+function buildBytesSortFn(name, arity, hasComparator, loc) {
+    const bytesT = BYTES_U8;
+    const fnT = funcOf([F64, F64].slice(0, arity), F64);
+    const ref = (localId, type) => ({
+        kind: "varRef",
+        localId,
+        type,
+        loc,
+    });
+    const num = (value) => ({
+        kind: "numLit",
+        value,
+        type: F64,
+        loc,
+    });
+    const j = ref("j.0", F64);
+    const at = (index) => ({
+        kind: "bytesIntrinsic",
+        method: "get",
+        receiver: ref("a.0", bytesT),
+        args: [index],
+        type: F64,
+        loc,
+    });
+    const jPlus1 = {
+        kind: "bin",
+        op: "+",
+        left: j,
+        right: num(1),
+        type: F64,
+        loc,
+    };
+    const compare = hasComparator
+        ? {
+            kind: "callValue",
+            callee: ref("f.0", fnT),
+            args: [at(j), ref("v.0", F64)].slice(0, arity),
+            type: F64,
+            loc,
+        }
+        : {
+            kind: "bin",
+            op: "-",
+            left: at(j),
+            right: ref("v.0", F64),
+            type: F64,
+            loc,
+        };
+    const shiftLoop = {
+        kind: "while",
+        cond: {
+            kind: "bin",
+            op: ">=",
+            left: j,
+            right: num(0),
+            type: BOOL,
+            loc,
+        },
+        body: [
+            {
+                kind: "if",
+                cond: {
+                    kind: "bin",
+                    op: ">",
+                    left: compare,
+                    right: num(0),
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    {
+                        kind: "bytesSet",
+                        arr: ref("a.0", bytesT),
+                        index: jPlus1,
+                        value: at(j),
+                        loc,
+                    },
+                    {
+                        kind: "assign",
+                        localId: "j.0",
+                        value: {
+                            kind: "bin",
+                            op: "-",
+                            left: j,
+                            right: num(1),
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                    },
+                ],
+                else_: [{ kind: "break", loc }],
+                loc,
+            },
+        ],
+        loc,
+    };
+    const params = [
+        { localId: "a.0", name: "a", type: bytesT },
+        ...(hasComparator
+            ? [{ localId: "f.0", name: "f", type: fnT }]
+            : []),
+    ];
+    const locals = [
+        { id: "a.0", name: "a", type: bytesT, mutable: true },
+        ...(hasComparator
+            ? [{ id: "f.0", name: "f", type: fnT, mutable: true }]
+            : []),
+        { id: "n.0", name: "n", type: F64, mutable: false },
+        { id: "i.0", name: "i", type: F64, mutable: true },
+        { id: "v.0", name: "v", type: F64, mutable: false },
+        { id: "j.0", name: "j", type: F64, mutable: true },
+    ];
+    const body = [
+        {
+            kind: "assign",
+            localId: "a.0",
+            value: {
+                kind: "bytesIntrinsic",
+                method: "slice",
+                receiver: ref("a.0", bytesT),
+                args: [],
+                type: bytesT,
+                loc,
+            },
+            loc,
+        },
+        {
+            kind: "varDecl",
+            localId: "n.0",
+            init: {
+                kind: "bytesIntrinsic",
+                method: "length",
+                receiver: ref("a.0", bytesT),
+                args: [],
+                type: F64,
+                loc,
+            },
+            loc,
+        },
+        {
+            kind: "for",
+            init: {
+                kind: "varDecl",
+                localId: "i.0",
+                init: num(1),
+                loc,
+            },
+            cond: {
+                kind: "bin",
+                op: "<",
+                left: ref("i.0", F64),
+                right: ref("n.0", F64),
+                type: BOOL,
+                loc,
+            },
+            update: {
+                kind: "assign",
+                localId: "i.0",
+                value: {
+                    kind: "bin",
+                    op: "+",
+                    left: ref("i.0", F64),
+                    right: num(1),
+                    type: F64,
+                    loc,
+                },
+                loc,
+            },
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: "v.0",
+                    init: at(ref("i.0", F64)),
+                    loc,
+                },
+                {
+                    kind: "varDecl",
+                    localId: "j.0",
+                    init: {
+                        kind: "bin",
+                        op: "-",
+                        left: ref("i.0", F64),
+                        right: num(1),
+                        type: F64,
+                        loc,
+                    },
+                    loc,
+                },
+                shiftLoop,
+                {
+                    kind: "bytesSet",
+                    arr: ref("a.0", bytesT),
+                    index: jPlus1,
+                    value: ref("v.0", F64),
+                    loc,
+                },
+            ],
+            loc,
+        },
+        { kind: "return", value: ref("a.0", bytesT), loc },
+    ];
+    return {
+        name,
+        params,
+        returnType: bytesT,
+        locals,
+        body,
+        loc,
+    };
+}
 /** `n = a.length` — the once-up-front length read every array HOF loop
    * starts with (locals a.0/n.0 by convention). */
 function readLenStmt(arrT, loc) {
@@ -3462,7 +3954,7 @@ export function lowerForOfSearchParams(L, stmt, iterable, proj) {
         L.scopes.pop();
     }
 }
-/** for-of over an ARRAY's keys()/entries() projections consumed directly
+/** for-of over an ARRAY/typed-array keys()/entries() projection consumed directly
    * by the head (`for (const [index, line] of lines.entries())` — the
    * dominant formatter idiom): the LIVE index walk — the length re-reads
    * every pass, exactly the array iterator's contract (elements appended
@@ -3477,7 +3969,7 @@ export function lowerForOfSearchParams(L, stmt, iterable, proj) {
 export function lowerForOfArrayIter(L, stmt, iterable, proj) {
     const loc = locOf(stmt);
     const arrT = iterable.type;
-    const elemT = arrT.elem;
+    const elemT = arrT.kind === "array" ? arrT.elem : F64;
     const yieldsPair = proj === "entries";
     if (!ts.isVariableDeclarationList(stmt.initializer)) {
         L.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
@@ -3497,7 +3989,22 @@ export function lowerForOfArrayIter(L, stmt, iterable, proj) {
         const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
         const num = (value) => ({ kind: "numLit", value, type: F64, loc });
         const keyRead = () => ref(i.id, F64);
-        const valRead = () => ({ kind: "arrayGet", arr: ref(arr.id, arrT), index: ref(i.id, F64), type: elemT, loc });
+        const valRead = () => arrT.kind === "array"
+            ? {
+                kind: "arrayGet",
+                arr: ref(arr.id, arrT),
+                index: ref(i.id, F64),
+                type: elemT,
+                loc,
+            }
+            : {
+                kind: "bytesIntrinsic",
+                method: "get",
+                receiver: ref(arr.id, arrT),
+                args: [ref(i.id, F64)],
+                type: F64,
+                loc,
+            };
         const binds = [];
         const isPlainIdent = (el) => ts.isBindingElement(el) && el.name !== undefined && ts.isIdentifier(el.name) && !el.initializer && !el.dotDotDotToken;
         if (yieldsPair &&
@@ -3576,7 +4083,23 @@ export function lowerForOfArrayIter(L, stmt, iterable, proj) {
                 kind: "bin",
                 op: "<",
                 left: ref(i.id, F64),
-                right: { kind: "arrIntrinsic", method: "length", receiver: ref(arr.id, arrT), args: [], type: F64, loc },
+                right: arrT.kind === "array"
+                    ? {
+                        kind: "arrIntrinsic",
+                        method: "length",
+                        receiver: ref(arr.id, arrT),
+                        args: [],
+                        type: F64,
+                        loc,
+                    }
+                    : {
+                        kind: "bytesIntrinsic",
+                        method: "length",
+                        receiver: ref(arr.id, arrT),
+                        args: [],
+                        type: F64,
+                        loc,
+                    },
                 type: BOOL,
                 loc,
             },
@@ -4406,6 +4929,60 @@ export function lowerBytesMethodCall(L, call, access) {
         return null;
     const loc = locOf(call);
     const nArgs = call.arguments.length;
+    if (receiverIr.elem === "u8" && name === "toSorted") {
+        return lowerBytesToSortedCall(L, call, access, receiverIr);
+    }
+    if (receiverIr.elem === "u8" && name === "toReversed") {
+        if (nArgs !== 0) {
+            L.noLowering(`.toReversed with ${nArgs} arguments on Uint8Array`, call);
+        }
+        return {
+            kind: "bytesIntrinsic",
+            method: "toReversed",
+            receiver: L.lowerExpr(access.expression),
+            args: [],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (receiverIr.elem === "u8" && name === "with") {
+        if (nArgs !== 2 || call.arguments.some(ts.isSpreadElement)) {
+            L.noLowering(`.with with ${nArgs} arguments on Uint8Array`, call);
+        }
+        return {
+            kind: "bytesIntrinsic",
+            method: "with",
+            receiver: L.lowerExpr(access.expression),
+            args: [
+                L.lowerExprExpecting(call.arguments[0], F64),
+                L.lowerExprExpecting(call.arguments[1], F64),
+            ],
+            type: receiverIr,
+            loc,
+        };
+    }
+    if (receiverIr.elem === "u8" && name === "join") {
+        if (nArgs > 1 || call.arguments.some(ts.isSpreadElement)) {
+            L.noLowering(`.join with ${nArgs} arguments on Uint8Array`, call);
+        }
+        const separatorDefault = {
+            kind: "strLit",
+            value: ",",
+            type: STRING,
+            loc,
+        };
+        const separator = call.arguments[0]
+            ? lowerOptionalDefaultArg(L, call.arguments[0], STRING, separatorDefault)
+            : separatorDefault;
+        return {
+            kind: "bytesIntrinsic",
+            method: "join",
+            receiver: L.lowerExpr(access.expression),
+            args: [separator],
+            type: STRING,
+            loc,
+        };
+    }
     if (name === "slice" || name === "subarray") {
         if (nArgs > 2) {
             L.noLowering(`.${name} with ${nArgs} arguments on typed arrays`, call);