@scriptc/compiler 0.4.0 → 0.4.1

package/dist/frontend/lowering/handle-properties.js

@@ -0,0 +1,281 @@
+/* Own properties that JavaScript adds to a native ChildProcess: execa's
+ * mixin assigns `spawned.kill = ...` and defines then/catch/finally with
+ * Reflect.defineProperty, and its callers await the child as a thenable.
+ *
+ * The runtime keeps such properties in a side table per child
+ * (scr_dyn_handle_props.c). Only programs that can add one link it: a
+ * JavaScript write of a property onto a typed child, or JavaScript that
+ * calls defineProperty in a program whose JavaScript loads child_process. Those programs install the table at
+ * start, and their defineProperty, getOwnPropertyDescriptor, thenable
+ * await and typed `child.on(event, listener)` calls take the entries that
+ * consult it. Every other program lowers exactly as before. */
+import * as ts from "../ts7/adapter.js";
+import { isJsSourceFile, locOf } from "../program.js";
+import { DYN, STRING, VOID } from "../../ir/ir.js";
+import { everyStmt } from "../../ir/traverse.js";
+import { tryLowerExpression } from "./expressions/try-lower-expression.js";
+import { ENTRY_NAME } from "./lowerer.js";
+/** `child.name = value` in a JavaScript file over a typed child: the write
+ * lands in the child's property table through its checked-dynamic box. */
+export function lowerChildPropertyWrite(lowerer, recv, target, value, loc) {
+    lowerer.writesOntoChildren = true;
+    return {
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "dyn.keySet",
+            args: [
+                lowerer.coerceToExpected(recv, DYN),
+                { kind: "strLit", value: target.name.text, type: STRING, loc },
+                lowerer.lowerExprExpecting(value, DYN),
+            ],
+            type: VOID,
+            loc,
+        },
+        loc,
+    };
+}
+/** `child.kill` as a value in a JavaScript file (`spawned.kill.bind(spawned)`):
+ * the method read off the child's checked-dynamic box, which answers a
+ * function acting on that child. */
+export function lowerChildMethodValue(lowerer, node) {
+    if (!ts.isPropertyAccessExpression(node) || node.questionDotToken)
+        return null;
+    if (!isJsSourceFile(ts.getSourceFileOfNode(node)))
+        return null;
+    const recv = tryLowerExpression(lowerer, node.expression);
+    if (recv?.type.kind !== "child")
+        return null;
+    lowerer.writesOntoChildren = true;
+    const loc = locOf(node);
+    return {
+        kind: "dynKeyGet",
+        value: lowerer.coerceToExpected(recv, DYN),
+        key: { kind: "strLit", value: node.name.text, type: STRING, loc },
+        type: DYN,
+        loc,
+    };
+}
+/** ChildProcess and EventEmitter member names: reads and calls of these on
+ * a typed child keep their typed lowering (or its diagnostic) unless the
+ * program assigns the name onto a child. */
+const CHILD_MEMBERS = new Set([
+    "addListener",
+    "channel",
+    "connected",
+    "disconnect",
+    "emit",
+    "eventNames",
+    "exitCode",
+    "getMaxListeners",
+    "kill",
+    "killed",
+    "listenerCount",
+    "listeners",
+    "off",
+    "on",
+    "once",
+    "pid",
+    "prependListener",
+    "prependOnceListener",
+    "rawListeners",
+    "ref",
+    "removeAllListeners",
+    "removeListener",
+    "send",
+    "setMaxListeners",
+    "signalCode",
+    "spawnargs",
+    "spawnfile",
+    "stderr",
+    "stdin",
+    "stdio",
+    "stdout",
+    "unref",
+]);
+/** What the program's JavaScript adds to children: `child.name = value`
+ * writes onto typed children in any JavaScript file of a program that
+ * loads child_process, and defineProperty calls in such a program. */
+function childAdditions(lowerer) {
+    let known = lowerer.childAdditions;
+    if (known)
+        return known;
+    const written = new Set();
+    const files = lowerer.program
+        .getImplementationSourceFiles()
+        .filter((sf) => !sf.isDeclarationFile && isJsSourceFile(sf));
+    const spawns = files.some((sf) => sf.text.includes("child_process"));
+    const defines = files.some((sf) => sf.text.includes("defineProperty"));
+    // A child can reach any module (`module.exports = (child) => { child.x =
+    // ... }`), so once some file loads child_process every JavaScript file's
+    // writes onto children count.
+    // A key that is not a literal may name any member, so every member then
+    // goes through the child's box.
+    let everyName = false;
+    const isChild = (e) => lowerer.mapTypeOf(lowerer.typeOf(e))?.kind === "child";
+    const key = (k) => {
+        if (ts.isIdentifier(k) || ts.isStringLiteralLike(k) || ts.isNumericLiteral(k))
+            written.add(k.text);
+        else
+            everyName = true;
+    };
+    for (const sf of spawns ? files : []) {
+        const visit = (node) => {
+            if (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                (ts.isPropertyAccessExpression(node.left) || ts.isElementAccessExpression(node.left)) &&
+                isChild(node.left.expression)) {
+                if (ts.isPropertyAccessExpression(node.left))
+                    written.add(node.left.name.text);
+                else
+                    key(node.left.argumentExpression);
+            }
+            // `Object.defineProperty(child, "kill", { value })`, its Reflect
+            // twin, and `Object.defineProperties(child, { kill: ... })`.
+            if (ts.isCallExpression(node) &&
+                ts.isPropertyAccessExpression(node.expression) &&
+                ts.isIdentifier(node.expression.expression) &&
+                (node.expression.expression.text === "Object" ||
+                    node.expression.expression.text === "Reflect")) {
+                const method = node.expression.name.text;
+                const [target, second] = node.arguments.nodes;
+                if (target && second && isChild(target)) {
+                    if (method === "defineProperty")
+                        key(second);
+                    else if (method === "defineProperties") {
+                        if (!ts.isObjectLiteralExpression(second))
+                            everyName = true;
+                        else
+                            for (const prop of second.properties.nodes) {
+                                const name = prop.name;
+                                if (name !== undefined &&
+                                    (ts.isIdentifier(name) ||
+                                        ts.isStringLiteralLike(name) ||
+                                        ts.isNumericLiteral(name)))
+                                    written.add(name.text);
+                                else
+                                    everyName = true;
+                            }
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sf);
+    }
+    known = { written, everyName, any: written.size > 0 || everyName || (spawns && defines) };
+    lowerer.childAdditions = known;
+    return known;
+}
+/** The typed child a JavaScript member access reads from, when the member
+ * is one the program may have added to it. `untyped` is the last resort
+ * when no typed lowering claimed the access (a receiver the checker does
+ * not type as a child, such as an untyped parameter the call site
+ * instantiated with one, or a member without a typed lowering): every
+ * member goes through the child's box. */
+function childReceiverOf(lowerer, access, untyped) {
+    if (access.questionDotToken || !isJsSourceFile(ts.getSourceFileOfNode(access)))
+        return null;
+    const additions = childAdditions(lowerer);
+    const typed = lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind === "child";
+    if (!untyped && (!typed || !additions.any))
+        return null;
+    const name = access.name.text;
+    if (!untyped && CHILD_MEMBERS.has(name) && !additions.everyName && !additions.written.has(name))
+        return null;
+    const recv = tryLowerExpression(lowerer, access.expression);
+    if (recv?.type.kind !== "child")
+        return null;
+    if (additions.any)
+        lowerer.writesOntoChildren = true;
+    return recv;
+}
+/** `child.name(...)` in JavaScript for a name the program adds to children
+ * (execa's `spawned.then(...)`, its replaced `spawned.kill(...)`), or on an
+ * untyped receiver holding a child (`untyped`): a member call on the
+ * child's checked-dynamic box. */
+export function lowerChildPropertyCall(lowerer, call, access, untyped = false) {
+    if (call.questionDotToken || call.arguments.nodes.some(ts.isSpreadElement))
+        return null;
+    const child = childReceiverOf(lowerer, access, untyped);
+    // `spawned.stdin.on(...)` over an untyped child: the member read off
+    // the child's box, then the call on that value.
+    const recv = child
+        ? lowerer.coerceToExpected(child, DYN)
+        : untyped && ts.isPropertyAccessExpression(access.expression)
+            ? lowerChildPropertyRead(lowerer, access.expression)
+            : null;
+    if (!recv)
+        return null;
+    const loc = locOf(call);
+    return {
+        kind: "dynInvoke",
+        recv,
+        method: access.name.text,
+        calleeName: ts.getTextOfNode(access),
+        args: call.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
+        type: DYN,
+        loc,
+    };
+}
+/** `child.name` in JavaScript over an untyped receiver holding a child, or
+ * for a name the program adds to children. */
+export function lowerChildPropertyRead(lowerer, access) {
+    const recv = childReceiverOf(lowerer, access, true) ?? childReceiverOf(lowerer, access, false);
+    if (!recv)
+        return null;
+    const loc = locOf(access);
+    return {
+        kind: "dynKeyGet",
+        value: lowerer.coerceToExpected(recv, DYN),
+        key: { kind: "strLit", value: access.name.text, type: STRING, loc },
+        type: DYN,
+        loc,
+    };
+}
+/** `await child` in JavaScript in a program that adds properties to
+ * children: the child may be a thenable (execa's mixin). */
+export function awaitsChildThenable(lowerer, node, value) {
+    if (value.type.kind !== "child" ||
+        !isJsSourceFile(ts.getSourceFileOfNode(node)) ||
+        !childAdditions(lowerer).any)
+        return false;
+    lowerer.writesOntoChildren = true;
+    return true;
+}
+const RENAMES = new Map([
+    ["dyn.defineProperty", "child.propsDefine"],
+    ["dyn.getOwnPropertyDescriptor", "child.propsDescriptor"],
+    ["dyn.promiseResolve", "child.propsResolve"],
+    ["child.onDyn", "child.propsOnDyn"],
+]);
+/** Switches a program that can add properties to children onto the
+ * property-table entries (in place) and installs the table in %main. */
+export function applyHandleProperties(lowerer, functions) {
+    if (!lowerer.writesOntoChildren && !childAdditions(lowerer).any)
+        return;
+    const calls = [];
+    const visitor = {
+        expr: (e) => {
+            if (e.kind === "libCall" && RENAMES.has(e.fn))
+                calls.push(e);
+            return true;
+        },
+        stmt: () => true,
+    };
+    for (const fn of functions)
+        for (const s of fn.body)
+            everyStmt(s, visitor);
+    for (const call of calls)
+        call.fn = RENAMES.get(call.fn);
+    const main = functions.find((fn) => fn.name === ENTRY_NAME);
+    if (!main)
+        return;
+    const loc = main.loc;
+    main.body.unshift({
+        kind: "exprStmt",
+        expr: { kind: "libCall", fn: "child.propsInstall", args: [], type: VOID, loc },
+        loc,
+    });
+}
+//# sourceMappingURL=handle-properties.js.map

package/dist/frontend/lowering/handle-properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-properties.js","sourceRoot":"","sources":["../../../src/frontend/lowering/handle-properties.ts"],"names":[],"mappings":"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"}

package/dist/frontend/lowering/iterable-spelling.d.ts

@@ -0,0 +1,7 @@
+import * as ts from "../ts7/adapter.js";
+/** V8's TypeError message for iterating a value that is not iterable:
+ * `x is not iterable` for an identifier or property path, `f is not a
+ * function or its return value is not iterable` for a call of one, and ""
+ * for other expressions, which the runtime words by the value's kind.
+ * for await words it with "async iterable". */
+export declare function notIterableSpelling(expr: ts.Expression, word?: string): string;

package/dist/frontend/lowering/iterable-spelling.js

@@ -0,0 +1,38 @@
+import * as ts from "../ts7/adapter.js";
+/** The expression under parentheses and type assertions, which leave no
+ * trace in the source text V8 prints. */
+function unwrapped(expr) {
+    let e = expr;
+    while (ts.isParenthesizedExpression(e) ||
+        ts.isAsExpression(e) ||
+        ts.isSatisfiesExpression(e) ||
+        ts.isNonNullExpression(e))
+        e = e.expression;
+    return e;
+}
+/** The source text V8 prints for an iterated identifier or property path,
+ * or null for other expressions. */
+function iterableHeadText(expr) {
+    const e = unwrapped(expr);
+    if (ts.isIdentifier(e))
+        return e.text;
+    if (ts.isPropertyAccessExpression(e) && !e.questionDotToken && ts.isIdentifier(e.name)) {
+        const base = iterableHeadText(e.expression);
+        return base === null ? null : `${base}.${e.name.text}`;
+    }
+    return null;
+}
+/** V8's TypeError message for iterating a value that is not iterable:
+ * `x is not iterable` for an identifier or property path, `f is not a
+ * function or its return value is not iterable` for a call of one, and ""
+ * for other expressions, which the runtime words by the value's kind.
+ * for await words it with "async iterable". */
+export function notIterableSpelling(expr, word = "iterable") {
+    const name = iterableHeadText(expr);
+    if (name !== null)
+        return `${name} is not ${word}`;
+    const e = unwrapped(expr);
+    const callee = ts.isCallExpression(e) ? iterableHeadText(e.expression) : null;
+    return callee !== null ? `${callee} is not a function or its return value is not ${word}` : "";
+}
+//# sourceMappingURL=iterable-spelling.js.map

package/dist/frontend/lowering/iterable-spelling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterable-spelling.js","sourceRoot":"","sources":["../../../src/frontend/lowering/iterable-spelling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAExC;yCACyC;AACzC,SAAS,SAAS,CAAC,IAAmB;IACpC,IAAI,CAAC,GAAG,IAAI,CAAC;IACb,OACE,EAAE,CAAC,yBAAyB,CAAC,CAAC,CAAC;QAC/B,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;QACpB,EAAE,CAAC,qBAAqB,CAAC,CAAC,CAAC;QAC3B,EAAE,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAEzB,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC;IACnB,OAAO,CAAC,CAAC;AACX,CAAC;AAED;oCACoC;AACpC,SAAS,gBAAgB,CAAC,IAAmB;IAC3C,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,IAAI,CAAC;IACtC,IAAI,EAAE,CAAC,0BAA0B,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,IAAI,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;QACvF,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;QAC5C,OAAO,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;IACzD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;+CAI+C;AAC/C,MAAM,UAAU,mBAAmB,CAAC,IAAmB,EAAE,IAAI,GAAG,UAAU;IACxE,MAAM,IAAI,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,GAAG,IAAI,WAAW,IAAI,EAAE,CAAC;IACnD,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC1B,MAAM,MAAM,GAAG,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9E,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,iDAAiD,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;AACjG,CAAC"}

package/dist/frontend/lowering/lower-array-sort.d.ts

@@ -1,32 +1,50 @@
 import { type IrExpr, type IrFunction, type IrType, type SrcLoc } from "../../ir/ir.js";
-type SortKeyRead = IrExpr & {
+type SortKeyField = IrExpr & {
     kind: "recordGet" | "fieldGet";
 };
-/** A comparator that orders by one number: the elements themselves or one
- * field of each, ascending or descending. */
+/** A key read over the comparator's first parameter: one number field, or
+ * an optional number field with a number default (`x.k ?? 0`). */
+export interface SortKeyRead {
+    field: SortKeyField;
+    fallback: (IrExpr & {
+        kind: "numLit";
+    }) | null;
+}
+/** One key of a comparator: the elements themselves or one field of each,
+ * ascending or descending. */
 export interface SortKeyOrder {
     /** 1 for ascending, -1 for descending. */
     order: 1 | -1;
-    /** The field read over the comparator's first parameter, or null when
-     * the elements are the numbers. */
+    /** The key read, or null when the elements are the numbers. */
     read: SortKeyRead | null;
 }
 /** Recognizes the lifted body of a capture-free numeric comparator:
  * `(a, b) => a - b`, `b - a`, `a < b ? -1 : a > b ? 1 : 0` (either test
  * first, either sign), or any of them over one number field of both
- * parameters (`a.k - b.k`). Such a comparator runs no user code, cannot
- * throw, and is consistent over numbers other than NaN, so the runtime may
- * order the elements by their keys without calling it. */
-export declare function recognizeKeyComparator(fn: IrFunction): SortKeyOrder | null;
-/** The key order of a comparator closure: a zero-capture closure (not a
+ * parameters (`a.k - b.k`, or `(a.k ?? 0) - (b.k ?? 0)` over an optional
+ * field). Such a comparator runs no user code, cannot throw, and is
+ * consistent over numbers other than NaN, so the runtime may order the
+ * elements by their keys without calling it. A chain `t0 || t1 || ...` of
+ * such terms over fields orders by several keys, the first deciding: a term
+ * that is 0 or NaN falls through to the next. Returns the keys in order. */
+export declare function recognizeKeyComparator(fn: IrFunction): readonly SortKeyOrder[] | null;
+/** The keys of a comparator closure: a zero-capture closure (not a
  * signature adapter) over a lifted function recognizeKeyComparator accepts. */
-export declare function closureKeyOrder(liftedFns: readonly IrFunction[], closure: IrExpr): SortKeyOrder | null;
-/** The key reader of a recognized field comparator: `(x) => x.k`, the same
- * field read as the comparator's. */
-export declare function buildSortKeyFn(name: string, elem: IrType, read: SortKeyRead, loc: SrcLoc): IrFunction;
+export declare function closureKeyOrder(liftedFns: readonly IrFunction[], closure: IrExpr): readonly SortKeyOrder[] | null;
+/** The order argument of a keyed sort: 1 or -1 for one key; for several,
+ * the key count in the low byte and, from bit 8, one bit per descending
+ * key (the runtime's SCR_SORT_KEYS encoding). */
+export declare function sortKeysOrder(keys: readonly SortKeyOrder[]): number;
+/** A cache key that identifies a recognized comparator's key reads. */
+export declare function sortKeysId(keys: readonly SortKeyOrder[]): string;
+/** The key reader of a recognized field comparator: `(x) => x.k` (or
+ * `x.k ?? d`), the same read as the comparator's. For several keys it takes
+ * the key's index too: `(x, j) => j === 0 ? key0 : j === 1 ? key1 : ...`. */
+export declare function buildSortKeyFn(name: string, elem: IrType, reads: readonly SortKeyRead[], loc: SrcLoc): IrFunction;
 export declare function buildArraySortFn(name: string, elem: IrType, arity: number, copyFirst: boolean, undefinedTag: number | null, loc: SrcLoc, native?: boolean, keyed?: {
-    order: 1 | -1;
+    order: number;
     key: boolean;
+    keys: number;
 } | null): IrFunction;
 /** Typed-array `sort` and `toSorted`. `toSorted` orders a private copy;
  * `sort` orders the receiver and returns it. Without a comparator, and for a

package/dist/frontend/lowering/lower-array-sort.js

@@ -605,28 +605,66 @@ function timSortBody(b, src, n, less) {
         forceCollapse,
     ];
 }
+/** Most keys a comparator chain is recognized with (the runtime's
+ * SCR_SORT_KEYS_MAX). */
+const MAX_SORT_KEYS = 8;
 /** Recognizes the lifted body of a capture-free numeric comparator:
  * `(a, b) => a - b`, `b - a`, `a < b ? -1 : a > b ? 1 : 0` (either test
  * first, either sign), or any of them over one number field of both
- * parameters (`a.k - b.k`). Such a comparator runs no user code, cannot
- * throw, and is consistent over numbers other than NaN, so the runtime may
- * order the elements by their keys without calling it. */
+ * parameters (`a.k - b.k`, or `(a.k ?? 0) - (b.k ?? 0)` over an optional
+ * field). Such a comparator runs no user code, cannot throw, and is
+ * consistent over numbers other than NaN, so the runtime may order the
+ * elements by their keys without calling it. A chain `t0 || t1 || ...` of
+ * such terms over fields orders by several keys, the first deciding: a term
+ * that is 0 or NaN falls through to the next. Returns the keys in order. */
 export function recognizeKeyComparator(fn) {
     if (fn.params.length !== 2 || fn.async || fn.generator || (fn.captures?.length ?? 0) > 0)
         return null;
-    const [first, second] = fn.params;
     const ret = fn.body.length === 1 ? fn.body[0] : null;
     if (ret?.kind !== "return" || !ret.value)
         return null;
+    const terms = [];
+    const flatten = (e) => {
+        if (e.kind === "logical" && e.op === "||" && e.type.kind === "f64") {
+            flatten(e.left);
+            flatten(e.right);
+        }
+        else
+            terms.push(e);
+    };
+    flatten(ret.value);
+    if (terms.length > MAX_SORT_KEYS)
+        return null;
+    const keys = [];
+    for (const term of terms) {
+        const key = recognizeKeyTerm(fn, term);
+        if (!key)
+            return null;
+        keys.push(key);
+    }
+    // Several keys order elements by their fields.
+    if (keys.length > 1 && keys.some((key) => key.read === null))
+        return null;
+    return keys;
+}
+/** One term of a key comparator over one key (recognizeKeyComparator). */
+function recognizeKeyTerm(fn, value) {
+    const [first, second] = fn.params;
     let read;
     // Which parameter an operand reads; every operand must read the same key.
     const operand = (e) => {
         if (e.type.kind !== "f64")
             return null;
         let ref = e;
-        let field = null;
-        if (e.kind === "recordGet" || e.kind === "fieldGet") {
-            field = e;
+        let key = null;
+        if (e.kind === "nullish" &&
+            (e.left.kind === "recordGet" || e.left.kind === "fieldGet") &&
+            e.right.kind === "numLit") {
+            key = { field: e.left, fallback: e.right };
+            ref = e.left.obj;
+        }
+        else if (e.kind === "recordGet" || e.kind === "fieldGet") {
+            key = { field: e, fallback: null };
             ref = e.obj;
         }
         if (ref.kind !== "varRef")
@@ -635,8 +673,8 @@ export function recognizeKeyComparator(fn) {
         if (param === null)
             return null;
         if (read === undefined)
-            read = field;
-        else if (!sameKeyRead(read, field))
+            read = key;
+        else if (!sameKeyRead(read, key))
             return null;
         return param;
     };
@@ -650,7 +688,6 @@ export function recognizeKeyComparator(fn) {
         return (e.op === "<") === (left === 0) ? "lt" : "gt";
     };
     const sign = (e) => e.kind === "numLit" && (e.value === 1 || e.value === -1 || e.value === 0) ? e.value : null;
-    const value = ret.value;
     if (value.kind === "bin" && value.op === "-") {
         const left = operand(value.left), right = operand(value.right);
         if (left === null || right === null || left === right)
@@ -673,7 +710,7 @@ export function recognizeKeyComparator(fn) {
     }
     return null;
 }
-/** The key order of a comparator closure: a zero-capture closure (not a
+/** The keys of a comparator closure: a zero-capture closure (not a
  * signature adapter) over a lifted function recognizeKeyComparator accepts. */
 export function closureKeyOrder(liftedFns, closure) {
     if (closure.kind !== "closure" || closure.captures.length > 0 || closure.adapts)
@@ -684,23 +721,81 @@ export function closureKeyOrder(liftedFns, closure) {
 function sameKeyRead(left, right) {
     if (left === null || right === null)
         return left === right;
-    if (left.kind === "recordGet" && right.kind === "recordGet")
-        return left.shapeId === right.shapeId && left.field === right.field;
-    if (left.kind === "fieldGet" && right.kind === "fieldGet")
-        return left.className === right.className && left.field === right.field;
+    if (!Object.is(left.fallback?.value, right.fallback?.value))
+        return false;
+    const a = left.field, b = right.field;
+    if (a.kind === "recordGet" && b.kind === "recordGet")
+        return a.shapeId === b.shapeId && a.field === b.field;
+    if (a.kind === "fieldGet" && b.kind === "fieldGet")
+        return a.className === b.className && a.field === b.field;
     return false;
 }
-/** The key reader of a recognized field comparator: `(x) => x.k`, the same
- * field read as the comparator's. */
-export function buildSortKeyFn(name, elem, read, loc) {
+/** The order argument of a keyed sort: 1 or -1 for one key; for several,
+ * the key count in the low byte and, from bit 8, one bit per descending
+ * key (the runtime's SCR_SORT_KEYS encoding). */
+export function sortKeysOrder(keys) {
+    if (keys.length === 1)
+        return keys[0].order;
+    return keys.reduce((code, key, j) => (key.order < 0 ? code | (1 << (8 + j)) : code), keys.length);
+}
+/** A cache key that identifies a recognized comparator's key reads. */
+export function sortKeysId(keys) {
+    return keys
+        .map((key) => {
+        if (!key.read)
+            return "self";
+        const field = key.read.field;
+        const owner = field.kind === "recordGet" ? field.shapeId : field.className;
+        const fallback = key.read.fallback
+            ? `??${Object.is(key.read.fallback.value, -0) ? "-0" : key.read.fallback.value}`
+            : "";
+        return `${field.kind}:${owner}:${field.field}${fallback}`;
+    })
+        .join("|");
+}
+/** The key reader of a recognized field comparator: `(x) => x.k` (or
+ * `x.k ?? d`), the same read as the comparator's. For several keys it takes
+ * the key's index too: `(x, j) => j === 0 ? key0 : j === 1 ? key1 : ...`. */
+export function buildSortKeyFn(name, elem, reads, loc) {
     const b = new SortIr(loc);
     const x = b.local("x", elem);
+    const read = (key) => {
+        const field = { ...key.field, obj: x, loc };
+        return key.fallback
+            ? { kind: "nullish", left: field, right: key.fallback, type: F64, loc }
+            : field;
+    };
+    if (reads.length === 1) {
+        return {
+            name,
+            params: [{ localId: x.localId, name: "x", type: elem }],
+            returnType: F64,
+            locals: b.locals,
+            body: distinctNodes([{ kind: "return", value: read(reads[0]), loc }]),
+            loc,
+        };
+    }
+    const j = b.local("j");
+    let value = read(reads[reads.length - 1]);
+    for (let index = reads.length - 2; index >= 0; index--) {
+        value = {
+            kind: "ternary",
+            cond: b.eq(j, b.num(index)),
+            then: read(reads[index]),
+            else_: value,
+            type: F64,
+            loc,
+        };
+    }
     return {
         name,
-        params: [{ localId: x.localId, name: "x", type: elem }],
+        params: [
+            { localId: x.localId, name: "x", type: elem },
+            { localId: j.localId, name: "j", type: F64 },
+        ],
         returnType: F64,
         locals: b.locals,
-        body: [{ kind: "return", value: { ...read, obj: x, loc }, loc }],
+        body: distinctNodes([{ kind: "return", value, loc }]),
         loc,
     };
 }
@@ -708,7 +803,8 @@ export function buildArraySortFn(name, elem, arity, copyFirst, undefinedTag, loc
     const b = new SortIr(loc);
     const arrT = arrayOf(elem), fnT = funcOf([elem, elem].slice(0, arity), F64);
     const a = b.local("a", arrT), f = b.local("f", fnT);
-    const keyT = funcOf([elem], F64);
+    // A reader of several keys takes the key's index too (buildSortKeyFn).
+    const keyT = funcOf(keyed && keyed.keys > 1 ? [elem, F64] : [elem], F64);
     const key = keyed?.key ? b.local("key", keyT) : null;
     // A recognized comparator lets the runtime order by keys; it still
     // receives the comparator for inputs whose keys it does not order.