@scriptc/compiler 0.0.9 → 0.0.11

package/dist/frontend/lowering/lower-containers.d.ts

@@ -274,6 +274,23 @@ export type ForOfIterProjection = "keys" | "values" | "entries";
    * enter/exit bracketing: the pair list compacts immediately (no
    * tombstones), so there is no iteration depth to keep exact. */
 export declare function lowerForOfSearchParams(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, proj?: ForOfIterProjection): IrStmt;
+/** for-of over an ARRAY's keys()/entries() projections 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
+   * mid-walk are visited; a shrink ends the loop early) — yielding the
+   * index (`keys`, a number) or the [index, element] pair (`entries`).
+   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
+   * `[i, v]` head of plain identifiers binds straight from the reads (the
+   * tuple never materializes); identifier heads and the remaining
+   * patterns bind through the checker's own element type — the interned
+   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
+   * (only the direct for-of position unwraps). */
+export declare function lowerForOfArrayIter(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr & {
+    type: IrType & {
+        kind: "array";
+    };
+}, proj: "keys" | "entries"): IrStmt;
 export declare function lowerForOfMap(L: Lowerer, stmt: ts.ForOfStatement, iterable: IrExpr, mapT: IrType & {
     kind: "map";
 }, proj?: ForOfIterProjection): IrStmt;
@@ -327,6 +344,10 @@ export declare function lowerBytesNew(L: Lowerer, expr: ts.NewExpression, symbol
    * else the lib declares (fill, indexOf, reverse, ...) falls through to
    * the SC2020 member fence. Null when this isn't a bytes method call. */
 export declare function lowerBytesMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+/** A literal encoding's canonical name, or undefined for a spelling Node
+ * does not know — the ladder callers (stream options) turn unknown
+ * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
+export declare function knownBufEncoding(name: string): string | undefined;
 /** The literal encoding argument of a Buffer surface, normalized — or a
  * fence when it isn't a literal alias Node knows. */
 export declare function bufEncoding(L: Lowerer, what: string, encNode: ts.Expression): string;

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

@@ -2649,23 +2649,27 @@ export function lowerIteratorHelperCall(L, call, access) {
     const terminal = access.name.text;
     if (!ITER_TERMINALS.has(terminal))
         return null;
-    // Walk receiver: stage* ← values() ← array-typed source.
+    // Walk receiver: stage* ← values()/entries() ← array-typed source
+    // (entries seeds the chain with [index, element] pairs — the
+    // checker's own tuple type).
     const stages = [];
     let cur = access.expression;
     let source = null;
+    let srcProj = "values";
     for (;;) {
         if (!ts.isCallExpression(cur) || !ts.isPropertyAccessExpression(cur.expression))
             return null;
         if (cur.questionDotToken || cur.expression.questionDotToken)
             return null;
         const name = cur.expression.name.text;
-        if (name === "values" && cur.arguments.length === 0) {
+        if ((name === "values" || name === "entries") && cur.arguments.length === 0) {
             const recvIr = L.mapTypeOf(L.typeOf(cur.expression.expression));
             if (recvIr?.kind !== "array")
                 return null;
             if (!L.isStdlibMember(cur.expression))
                 return null;
             source = cur.expression.expression;
+            srcProj = name;
             break;
         }
         if (!ITER_STAGES.has(name) || cur.arguments.length !== 1 || ts.isSpreadElement(cur.arguments[0]))
@@ -2687,7 +2691,12 @@ export function lowerIteratorHelperCall(L, call, access) {
     const items = L.lowerExpr(source);
     if (items.type.kind !== "array")
         return null;
-    let elem = items.type.elem;
+    // The entries() seed: the interned [number, T] tuple — the same shape
+    // the checker's own [number, T] maps to, so stage callbacks typed
+    // against the lib's pairs intern equal.
+    let elem = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: items.type.elem }], true) }
+        : items.type.elem;
     const stageIrs = [];
     for (const s of stages) {
         if (s.name === "take" || s.name === "drop") {
@@ -2774,12 +2783,12 @@ export function lowerIteratorHelperCall(L, call, access) {
         L.noLowering(`.${terminal} at this result type`, call, "the chain's element and result types must be representable — annotate the callbacks' types");
     }
     const stageKeys = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.kind : `${s.kind}:${typeKey(s.fn.type)}`));
-    const key = `iter:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
+    const key = `iter:${srcProj}:${typeKey(items.type)}:${stageKeys.join(",")}:${terminal}:${termArgs.map((a) => typeKey(a.type)).join(",")}`;
     let helper = L.arrHofHelpers.get(key);
     if (!helper) {
         helper = `%iter.${terminal}.${L.arrHofHelpers.size}`;
         L.arrHofHelpers.set(key, helper);
-        L.liftedFns.push(buildIterChainFn(L, helper, items.type, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
+        L.liftedFns.push(buildIterChainFn(L, helper, items.type, srcProj, stageIrs, terminal, termArgs.map((a) => a.type), resultT, loc));
     }
     const budgetOrFn = stageIrs.map((s) => (s.kind === "take" || s.kind === "drop" ? s.budget : s.fn));
     return { kind: "call", callee: helper, args: [items, ...budgetOrFn, ...termArgs], type: resultT, loc };
@@ -2862,7 +2871,7 @@ function internBudgetChecker(L, loc) {
    * source order, flatMap as an inner loop over its returned array.
    * Pre-loop, a zero take budget marks done immediately — Node pulls
    * nothing at all through a take(0). */
-function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT, loc) {
+function buildIterChainFn(L, name, itemsT, srcProj, stages, terminal, termArgTs, resultT, loc) {
     const ref = (localId, type) => ({ kind: "varRef", localId, type, loc });
     const num = (value) => ({ kind: "numLit", value, type: F64, loc });
     const boolLit = (value) => ({ kind: "boolLit", value, type: BOOL, loc });
@@ -2883,7 +2892,12 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
     const doneId = addLocal("done", BOOL, true);
     const done = () => ref(doneId, BOOL);
     const setDone = { kind: "assign", localId: doneId, value: boolLit(true), loc };
-    let elem = itemsT.elem;
+    // The entries() seed builds each pass's [index, element] pair — the
+    // same interned tuple the caller computed its stage types against.
+    const seedT = srcProj === "entries"
+        ? { kind: "record", shapeId: L.shapes.intern([{ name: "0", type: F64 }, { name: "1", type: itemsT.elem }], true) }
+        : itemsT.elem;
+    let elem = seedT;
     const slots = [];
     for (const s of stages) {
         if (s.kind === "take" || s.kind === "drop") {
@@ -3128,7 +3142,19 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         }
     }
     const iId = addLocal("i", F64, true);
-    const vId = addLocal("v", itemsT.elem, false);
+    const vId = addLocal("v", seedT, false);
+    const elemRead = () => ({ kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc });
+    const seedInit = srcProj === "entries"
+        ? {
+            kind: "recordLit",
+            fields: [
+                { name: "0", value: ref(iId, F64) },
+                { name: "1", value: elemRead() },
+            ],
+            type: seedT,
+            loc,
+        }
+        : elemRead();
     const loop = {
         kind: "for",
         init: { kind: "varDecl", localId: iId, init: num(0), loc },
@@ -3142,8 +3168,8 @@ function buildIterChainFn(L, name, itemsT, stages, terminal, termArgTs, resultT,
         },
         update: { kind: "assign", localId: iId, value: { kind: "bin", op: "+", left: ref(iId, F64), right: num(1), type: F64, loc }, loc },
         body: [
-            { kind: "varDecl", localId: vId, init: { kind: "arrayGet", arr: ref("items.0", itemsT), index: ref(iId, F64), type: itemsT.elem, loc }, loc },
-            ...emit(ref(vId, itemsT.elem)),
+            { kind: "varDecl", localId: vId, init: seedInit, loc },
+            ...emit(ref(vId, seedT)),
         ],
         loc,
     };
@@ -3436,6 +3462,143 @@ export function lowerForOfSearchParams(L, stmt, iterable, proj) {
         L.scopes.pop();
     }
 }
+/** for-of over an ARRAY's keys()/entries() projections 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
+   * mid-walk are visited; a shrink ends the loop early) — yielding the
+   * index (`keys`, a number) or the [index, element] pair (`entries`).
+   * `values` never lands here: lowerForOf's receiver unwrap owns it. A
+   * `[i, v]` head of plain identifiers binds straight from the reads (the
+   * tuple never materializes); identifier heads and the remaining
+   * patterns bind through the checker's own element type — the interned
+   * [number, T] tuple record. Stored iterator OBJECTS keep their fence
+   * (only the direct for-of position unwraps). */
+export function lowerForOfArrayIter(L, stmt, iterable, proj) {
+    const loc = locOf(stmt);
+    const arrT = iterable.type;
+    const elemT = arrT.elem;
+    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 ...))");
+    }
+    const list = stmt.initializer;
+    if ((list.flags & ts.NodeFlags.Using) !== 0) {
+        L.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
+    }
+    const isVar = (list.flags & ts.NodeFlags.BlockScoped) === 0;
+    const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || isVar;
+    const decl = list.declarations[0]; // the grammar allows exactly one
+    L.scopes.push(new Map());
+    try {
+        const arr = L.declareHiddenLocal("%arof", arrT);
+        const i = L.declareHiddenLocal("%iterof", F64);
+        i.mutable = true;
+        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 binds = [];
+        const isPlainIdent = (el) => ts.isBindingElement(el) && el.name !== undefined && ts.isIdentifier(el.name) && !el.initializer && !el.dotDotDotToken;
+        if (yieldsPair &&
+            !isVar && // var pattern names assign hoisted slots — the generic desugar below owns them
+            ts.isArrayBindingPattern(decl.name) &&
+            decl.name.elements.length >= 1 && decl.name.elements.length <= 2 &&
+            decl.name.elements.every(isPlainIdent)) {
+            // `for (const [i, v] of xs.entries())` — bind straight from the
+            // reads; the tuple never exists. `[i]` alone reads only the index.
+            const els = decl.name.elements;
+            const kLocal = L.declareLocal(els[0].name, els[0].name.text, F64, isLet);
+            binds.push({ kind: "varDecl", localId: kLocal.id, init: keyRead(), loc });
+            if (els[1]) {
+                const vLocal = L.declareLocal(els[1].name, els[1].name.text, elemT, isLet);
+                binds.push({ kind: "varDecl", localId: vLocal.id, init: valRead(), loc });
+            }
+        }
+        else {
+            // Identifier heads and the remaining patterns bind through the
+            // checker's own element type — [number, T] for pair yields,
+            // number otherwise — the Map desugar's exact shape.
+            const declT = L.mapTypeOf(L.checker.getTypeAtLocation(decl.name));
+            if (yieldsPair) {
+                const shape = declT?.kind === "record" ? L.shapes.get(declT.shapeId) : null;
+                if (declT?.kind !== "record" || !shape?.tuple || shape.fields.length !== 2 ||
+                    shape.fields.find((f) => f.name === "0")?.type.kind !== "f64" ||
+                    !typeEquals(shape.fields.find((f) => f.name === "1")?.type ?? F64, elemT)) {
+                    L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares [number, T]
+                }
+            }
+            else if (declT?.kind !== "f64") {
+                L.badType(decl.name, L.checker.getTypeAtLocation(decl.name)); // defensive: the lib declares number
+            }
+            const elemInit = yieldsPair
+                ? {
+                    kind: "recordLit",
+                    fields: [
+                        { name: "0", value: keyRead() },
+                        { name: "1", value: valRead() },
+                    ],
+                    type: declT,
+                    loc,
+                }
+                : keyRead();
+            if (ts.isIdentifier(decl.name)) {
+                const varTarget = forOfVarTarget(L, decl);
+                if (varTarget) {
+                    // `for (var x of ...)`: one function-scoped binding, assigned
+                    // per pass — closures made in the loop share it, and the value
+                    // persists after the loop (both Node-exact for var).
+                    const tmp = L.declareHiddenLocal("%vof", declT);
+                    binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                    binds.push({
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(decl.name, { kind: "varRef", localId: tmp.id, type: declT, loc }, varTarget.type),
+                        loc,
+                    });
+                }
+                else {
+                    const local = L.declareLocal(decl.name, decl.name.text, declT, isLet);
+                    binds.push({ kind: "varDecl", localId: local.id, init: elemInit, loc });
+                }
+            }
+            else {
+                const tmp = L.declareHiddenLocal("%destr", declT);
+                binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit, loc });
+                L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: declT, loc }), declT, isLet, binds);
+            }
+        }
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement));
+        const loop = {
+            kind: "for",
+            init: { kind: "varDecl", localId: i.id, init: num(0), loc },
+            cond: {
+                kind: "bin",
+                op: "<",
+                left: ref(i.id, F64),
+                right: { kind: "arrIntrinsic", method: "length", receiver: ref(arr.id, arrT), args: [], type: F64, loc },
+                type: BOOL,
+                loc,
+            },
+            update: {
+                kind: "assign",
+                localId: i.id,
+                value: { kind: "bin", op: "+", left: ref(i.id, F64), right: num(1), type: F64, loc },
+                loc,
+            },
+            body: [...binds, ...body],
+            loc,
+        };
+        return {
+            kind: "block",
+            body: [{ kind: "varDecl", localId: arr.id, init: iterable, loc }, loop],
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 export function lowerForOfMap(L, stmt, iterable, mapT, proj) {
     return lowerForOfMapOrSet(L, stmt, iterable, mapT, proj);
 }
@@ -3841,9 +4004,26 @@ export function lowerRegexMethodCall(L, call, access, dynReceiver) {
     // [whole match, ...captures] or the null arm. The g-flag match returns
     // EVERY match (a different shape) and /y is stateful — both fence at
     // compile time on literal arguments (values reaching the runtime with
-    // those flags abort, the test() stance). `.index`/`.input`/`.groups`
-    // reads on the result fence per member (array-typed value).
-    if (receiverKind === "string" && name === "match") {
+    // those flags abort, the test() stance). `.index`/`.input` reads on
+    // the result fence per member (array-typed value); `.groups` reads
+    // desugar at their access sites when the regex is statically known
+    // (lowerMatchGroupsRead).
+    // `s.match(re)` also claims a NULLABLE string receiver (string + unit
+    // arms — `process.versions.openssl.match(...)`, the Dict<string>
+    // member the node suite's crypto helper reads): the checked
+    // extraction narrows to the string arm and a unit value throws the
+    // catchable TypeError at the read, where Node's own member read
+    // throws — tsc only admits the spelling in JS sources.
+    const nullableStringRecv = receiverKind === "union" &&
+        name === "match" &&
+        (() => {
+            const t = L.mapTypeOf(L.typeOf(access.expression));
+            if (t?.kind !== "union")
+                return false;
+            const arms = L.unions.get(t.unionId)?.arms ?? [];
+            return arms.some((a) => a.kind === "string") && arms.every((a) => a.kind === "string" || isUnitType(a));
+        })();
+    if ((receiverKind === "string" || nullableStringRecv) && name === "match") {
         const arg0 = call.arguments[0];
         if (!arg0 || L.mapTypeOf(L.typeOf(arg0))?.kind !== "regex")
             return null; // string-pattern match: the SC2020 fence
@@ -3858,7 +4038,7 @@ export function lowerRegexMethodCall(L, call, access, dynReceiver) {
                 L.unsupported("SC1120", call, "'.match()' with the 'g' or 'y' flag (an every-match array is a different shape — use replaceAll/split, or test() per position)");
             }
         }
-        const receiver = lowerReceiver();
+        const receiver = nullableStringRecv ? L.lowerExprExpecting(access.expression, STRING) : lowerReceiver();
         const re = L.lowerExpr(arg0);
         // RegExpMatchArray | null maps to the string[] | null union by
         // itself; intern it directly when the checker's spelling doesn't —
@@ -4232,8 +4412,30 @@ export function lowerBytesMethodCall(L, call, access) {
         }
         const receiver = L.lowerExpr(access.expression);
         const args = call.arguments.map((a) => L.lowerExprExpecting(a, F64));
-        // subarray COPIES here (no views exist) — SEMANTICS.md documents it.
-        return { kind: "bytesIntrinsic", method: "slice", receiver, args, type: receiverIr, loc };
+        // subarray is a VIEW (TypedArray.prototype.subarray aliases), and
+        // Buffer's slice() is subarray's deprecated Node alias — resolved by
+        // where the member is declared, the toString discipline below. Only
+        // the plain typed arrays' slice() copies (JS-exact).
+        const declaredOnBuffer = name === "slice" &&
+            (() => {
+                const nameSym = L.checker.getSymbolAtLocation(access.name);
+                return nameSym !== undefined && L.checker.declarationsOf(nameSym).some((d) => ts.isInterfaceDeclaration(d.parent) && d.parent.name.text === "Buffer");
+            })();
+        const method = name === "subarray" || declaredOnBuffer ? "subarray" : "slice";
+        return { kind: "bytesIntrinsic", method, receiver, args, type: receiverIr, loc };
+    }
+    if (name === "fill" && receiverIr.elem !== "u8") {
+        // TypedArray.prototype.fill on the non-u8 kinds: per-element value
+        // coercion, slice-clamped relative indices, never throws. u8
+        // receivers keep the Buffer fill family (string patterns, throwing
+        // offset validation) — lowerBufferInstanceMethod's surface.
+        if (nArgs < 1 || nArgs > 3) {
+            L.noLowering(`.fill with ${nArgs} arguments on typed arrays`, call);
+        }
+        const receiver = L.lowerExpr(access.expression);
+        const v = L.lowerExprExpecting(call.arguments[0], F64);
+        const idx = call.arguments.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+        return { kind: "bytesIntrinsic", method: "fillElem", receiver, args: [v, ...idx], type: receiverIr, loc };
     }
     if (name === "set") {
         if (nArgs < 1 || nArgs > 2) {
@@ -4408,6 +4610,12 @@ const BUF_ENCODINGS = {
     ucs2: "utf16le",
     "ucs-2": "utf16le",
 };
+/** A literal encoding's canonical name, or undefined for a spelling Node
+ * does not know — the ladder callers (stream options) turn unknown
+ * literals into Node's runtime ERR_UNKNOWN_ENCODING throw. */
+export function knownBufEncoding(name) {
+    return own(BUF_ENCODINGS, name);
+}
 /** The literal encoding argument of a Buffer surface, normalized — or a
  * fence when it isn't a literal alias Node knows. */
 export function bufEncoding(L, what, encNode) {
@@ -4690,6 +4898,22 @@ export function lowerBufferStaticCall(L, call, access) {
     const loc = locOf(call);
     const args = call.arguments;
     if (member === "from") {
+        // Buffer.from(x.buffer[, byteOffset[, length]]): a u8 VIEW sharing
+        // x's storage (Node shares the ArrayBuffer; length is in BYTES).
+        // The first argument must be the SYNTACTIC `.buffer` of a typed
+        // array — the DataView peel — and the construction rides the same
+        // dataViewNew intrinsic (offset/length validation throws Node's
+        // DataView-shaped RangeErrors; valid indices behave exactly).
+        if (args.length >= 1 && args.length <= 3 && !args.some(ts.isSpreadElement) &&
+            ts.isPropertyAccessExpression(args[0]) && args[0].name.text === "buffer") {
+            const srcNode = args[0].expression;
+            const srcIr = L.mapTypeOf(L.typeOf(srcNode));
+            if (srcIr?.kind === "bytes") {
+                const receiver = L.lowerExpr(srcNode);
+                const idxArgs = args.slice(1).map((a) => L.lowerExprExpecting(a, F64));
+                return { kind: "bytesIntrinsic", method: "dataViewNew", receiver, args: idxArgs, type: BYTES_U8, loc };
+            }
+        }
         if (args.length >= 1 && args.length <= 2 && !ts.isSpreadElement(args[0])) {
             const argNode = args[0];
             if (ts.isArrayLiteralExpression(argNode) && !argNode.elements.some(ts.isSpreadElement)) {
@@ -4719,7 +4943,8 @@ export function lowerBufferStaticCall(L, call, access) {
             }
         }
         L.noLowering("Buffer.from with this argument shape", call, "supported: Buffer.from(string, encoding?) with a literal encoding, Buffer.from(u8Array) — a copy — " +
-            "or Buffer.from(number[]); ArrayBuffers do not exist here (narrow unions first)");
+            "Buffer.from(number[]), or Buffer.from(x.buffer, byteOffset?, length?) — a view sharing x's " +
+            "storage (no free-standing ArrayBuffer value exists; narrow unions first)");
     }
     if (member === "alloc" || member === "allocUnsafe") {
         const maxArgs = member === "alloc" ? 3 : 1;
@@ -6305,6 +6530,26 @@ export function lowerDynArrayFlatMapCall(L, call, access, recv) {
     const { fnArg, arity } = hofCallbackArg(L, argNode, [DYN], DYN);
     const ret = fnArg.type.ret;
     if (ret.kind !== "array") {
+        // A DYNAMIC-returning callback (`plugins.flatMap((plugin) =>
+        // plugin.languages ?? [])` — the getSupportInfo shape, where the
+        // callback's members ride the DOM): the call dispatches on the
+        // RECEIVER's runtime kind (dynInvoke) with the callback boxed —
+        // a wrapped ISLAND receiver runs the ENGINE's own JS-exact
+        // Array.prototype.flatMap (the routed-ops lane), a native DOM
+        // array runs the runtime's flatMap, and non-arrays throw Node's
+        // TypeError. The result stays dyn, checked per use.
+        if (ret.kind === "dyn" || ret.kind === "jsval") {
+            const boxed = { kind: "dynFrom", value: fnArg, type: DYN, loc };
+            return {
+                kind: "dynInvoke",
+                recv,
+                method: "flatMap",
+                calleeName: access.getText(),
+                args: [boxed],
+                type: DYN,
+                loc,
+            };
+        }
         L.unsupported("SC1090", call, `'.flatMap' on 'unknown' receivers whose callback returns '${L.fmt(ret)}' ` +
             `(only callbacks returning a typed ARRAY compile — the results concatenate ` +
             `without validation; return one-element/empty arrays instead of bare values)`);