@scriptc/compiler 0.4.1 → 0.4.3

package/dist/ir/runtime-features.js

@@ -1,9 +1,8 @@
-import { isDirentShape, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_STREAM_CLASSES, } from "./ir.js";
+import { isDirentShape, recordTextCodecClass, RUNTIME_EMITTER_CLASS, RUNTIME_EVENT_CLASS, RUNTIME_EVENT_TARGET_CLASS, RUNTIME_STREAM_CLASSES, } from "./ir.js";
 import { everyModuleNode } from "./traverse.js";
+import { eachNodeOfKinds } from "./node-index.js";
 import { JsIcSites, hasJsIcSite } from "./js-ic.js";
-/** The fixed-width Buffer read/write method names (both "UInt" and "Uint"
- * spellings) a checked-dynamic method call routes to scr_bytes_dyn.c. */
-export const DYN_BUFFER_NUM_METHODS = new Set(["read", "write"].flatMap((rw) => [
+const DYN_BUFFER_NUM_METHODS = new Set(["read", "write"].flatMap((rw) => [
     ...["UInt", "Uint"].flatMap((u) => ["8", "16LE", "16BE", "32LE", "32BE"].map((w) => `${rw}${u}${w}`)),
     ...[
         "Int8",
@@ -17,6 +16,43 @@ export const DYN_BUFFER_NUM_METHODS = new Set(["read", "write"].flatMap((rw) =>
         "DoubleBE",
     ].map((n) => `${rw}${n}`),
 ]));
+/** Buffer.prototype members scr_bytes_dyn.c refuses on Buffer receivers. */
+const DYN_BUFFER_REFUSED_METHODS = [
+    ...["read", "write"].flatMap((rw) => [
+        ...["UIntLE", "UIntBE", "UintLE", "UintBE", "IntLE", "IntBE"].map((n) => `${rw}${n}`),
+        ...["BigUInt64", "BigUint64", "BigInt64"].flatMap((n) => [`${rw}${n}LE`, `${rw}${n}BE`]),
+    ]),
+    ...["ascii", "base64", "base64url", "latin1", "hex", "ucs2", "utf8"].flatMap((enc) => [
+        `${enc}Slice`,
+        `${enc}Write`,
+    ]),
+    "inspect",
+];
+/** The scr_bytes_dyn.c entry, one per method family, that a checked-dynamic
+ * call of a Buffer.prototype method name routes to: the fixed-width reads and
+ * writes (both "UInt" and "Uint" spellings), write, fill, toString, the
+ * searches, and the other Buffer-only members. Each runs the method on a
+ * Buffer receiver and gives any other receiver the ordinary dispatch. */
+export const DYN_BUFFER_METHODS = new Map([
+    ...[...DYN_BUFFER_NUM_METHODS].map((m) => [m, "scr_dyn_invoke_buffer_num"]),
+    ["write", "scr_dyn_invoke_buffer_write"],
+    ["fill", "scr_dyn_invoke_buffer_fill"],
+    ["toString", "scr_dyn_invoke_buffer_to_string"],
+    ...["indexOf", "lastIndexOf", "includes"].map((m) => [
+        m,
+        "scr_dyn_invoke_buffer_search",
+    ]),
+    ...[
+        "toJSON",
+        "equals",
+        "compare",
+        "copy",
+        "swap16",
+        "swap32",
+        "swap64",
+        ...DYN_BUFFER_REFUSED_METHODS,
+    ].map((m) => [m, "scr_dyn_invoke_buffer"]),
+]);
 const DYN_ASYNC_LIB_FNS = new Set([
     // DEP0040 rides the dyn-async unit's warning machinery.
     "async.awaitDyn",
@@ -24,6 +60,8 @@ const DYN_ASYNC_LIB_FNS = new Set([
     "child.propsInstall",
     "child.propsResolve",
     "crypto.native",
+    // The crypto global's object extends crypto.native's.
+    "webcrypto.object",
     "dyn.promiseAll",
     "dyn.promiseAllSettled",
     "dyn.promiseAny",
@@ -156,6 +194,21 @@ const ABORT_SIGNAL_LIB_FNS = new Set([
 /** Entry points that link the stream unit (with STREAM_LIB_PREFIXES). */
 const STREAM_LIB_FNS = new Set([
     "child.stdioStream",
+    "stream.chunkDone",
+    "stream.objectMode",
+    "stream.decodeStrings",
+    "stream.optionValues",
+    "stream.checkEncodingOption",
+    "stream.duplexFromGen",
+    "stream.duplexFromDyn",
+    "stream.duplexFromPromise",
+    "stream.duplexFromAsyncFn",
+    "stream.duplexFromGenSignal",
+    "stream.duplexFromAsyncFnSignal",
+    "fetch.readableFromWeb",
+    "stream.duplexifyReadable",
+    "stream.duplexifyWritable",
+    "stream.duplexifyPair",
     "console.bind",
     "crypto.hashStream",
     "crypto.hashStreamPiped",
@@ -168,6 +221,7 @@ const STREAM_LIB_FNS = new Set([
     "sp.finished",
     "sp.pipeline",
     "sp.pipelineStages",
+    "sp.pipelineStagesOpts",
     "stream.addAbortSignal",
     "stream.addAbortSignalFn",
     "stream.destroy",
@@ -179,6 +233,7 @@ const STREAM_LIB_FNS = new Set([
     "stream.prop",
     "stream.stdioWritable",
     "stream.unboxDyn",
+    "stream.handleStream",
     "stream.unpipeDyn",
     "stream.workerStdio",
 ]);
@@ -193,6 +248,7 @@ const STREAM_LIB_PREFIXES = [
     "sp.pipelineOpts",
     "stream.finishedOpts",
     "stream.pipelineStages",
+    "stream.composeStages",
     "stream.set",
     "transform.",
     "writable.",
@@ -205,6 +261,12 @@ const READABLE_DYN_ASYNC_LIB_FNS = new Set([
     "readable.fromDone",
     "readable.fromDyn",
     "readable.fromIter",
+    "stream.duplexFromGen",
+    "stream.duplexFromDyn",
+    "stream.duplexFromPromise",
+    "stream.duplexFromAsyncFn",
+    "stream.duplexFromGenSignal",
+    "stream.duplexFromAsyncFnSignal",
 ]);
 /** libCall name prefixes of the Readable entry points that await through the dyn-async unit. */
 const READABLE_DYN_ASYNC_PREFIXES = ["readable.fromGen", "readable.op"];
@@ -302,8 +364,10 @@ const COPYING_BYTES_METHODS = new Set([
 export function isDynUndefined(e) {
     return e.kind === "dynFrom" && e.value.kind === "unitLit" && e.value.unit === "undefined";
 }
-export function moduleRuntimeFeatures(mod) {
-    return scanRuntimeFeatures(mod);
+/** With `nodes` (the module's node index), the scan reads the recorded
+ * expressions and types instead of walking the module. */
+export function moduleRuntimeFeatures(mod, nodes) {
+    return scanRuntimeFeatures(mod, undefined, nodes);
 }
 /** Whether boxing a value of type `t` as dyn boxes a promise, which goes
  * through scr_async_dyn.c: a promise, a function whose result type holds
@@ -363,22 +427,23 @@ function boxesPromise(t, tables, seen) {
             return false;
     }
 }
-/** Whether `t` carries a dgram socket, given the carrier sets so far:
- * structural through functions (parameters and result), promises and
- * collections; named records, unions and class instances by the sets. */
-function carriesDgram(t, carriers) {
+/** Whether `t` carries a leaf, given the carrier sets so far: structural
+ * through functions (parameters and result), promises and collections;
+ * named records, unions and class instances by the sets. */
+function carriesLeaf(t, carriers, leaf, tables) {
+    if (leaf(t, tables))
+        return true;
     switch (t.kind) {
-        case "dgramSocket":
-            return true;
         case "func":
-            return t.params.some((p) => carriesDgram(p, carriers)) || carriesDgram(t.ret, carriers);
+            return (t.params.some((p) => carriesLeaf(p, carriers, leaf, tables)) ||
+                carriesLeaf(t.ret, carriers, leaf, tables));
         case "promise":
-            return carriesDgram(t.inner, carriers);
+            return carriesLeaf(t.inner, carriers, leaf, tables);
         case "array":
         case "set":
-            return carriesDgram(t.elem, carriers);
+            return carriesLeaf(t.elem, carriers, leaf, tables);
         case "map":
-            return carriesDgram(t.key, carriers) || carriesDgram(t.value, carriers);
+            return (carriesLeaf(t.key, carriers, leaf, tables) || carriesLeaf(t.value, carriers, leaf, tables));
         case "record":
             return carriers.records.has(t.shapeId);
         case "union":
@@ -390,37 +455,65 @@ function carriesDgram(t, carriers) {
             return false;
     }
 }
-/** The module's dgram carriers: a fixpoint over its records, unions and
+/** The module's carriers of `leaf`: a fixpoint over its records, unions and
  * class fields. */
-function dgramCarriers(tables) {
+function leafCarriers(tables, leaf) {
     const carriers = { records: new Set(), unions: new Set(), anyClass: false };
+    const carries = (t) => carriesLeaf(t, carriers, leaf, tables);
     for (let changed = true; changed;) {
         changed = false;
         for (const [id, shape] of tables.records)
-            if (!carriers.records.has(id) && shape.fields.some((f) => carriesDgram(f.type, carriers))) {
+            if (!carriers.records.has(id) &&
+                (leaf({ kind: "record", shapeId: id }, tables) || shape.fields.some((f) => carries(f.type)))) {
                 carriers.records.add(id);
                 changed = true;
             }
         for (const [id, def] of tables.unions)
-            if (!carriers.unions.has(id) && def.arms.some((a) => carriesDgram(a, carriers))) {
+            if (!carriers.unions.has(id) && def.arms.some(carries)) {
                 carriers.unions.add(id);
                 changed = true;
             }
         if (!carriers.anyClass &&
-            [...tables.classes.values()].some((c) => c.fields.some((f) => carriesDgram(f.type, carriers)))) {
+            [...tables.classes.values()].some((c) => c.fields.some((f) => carries(f.type)))) {
             carriers.anyClass = true;
             changed = true;
         }
     }
     return carriers;
 }
+const dgramLeaf = (t) => t.kind === "dgramSocket";
 /** Whether converting a value of type `t` to or from dyn converts a dgram
  * socket, which goes through scr_dgram_dyn.c: the socket itself, or a
  * function, collection, record, union, promise or class instance that
  * carries one (boxed functions convert their parameters too). */
 function mentionsDgramSocket(t, tables) {
-    tables.dgramCarriers ??= dgramCarriers(tables);
-    return carriesDgram(t, tables.dgramCarriers);
+    tables.dgramCarriers ??= leafCarriers(tables, dgramLeaf);
+    return carriesLeaf(t, tables.dgramCarriers, dgramLeaf, tables);
+}
+const textCodecLeaf = (t, tables) => {
+    if (t.kind !== "record")
+        return false;
+    const shape = tables.records.get(t.shapeId);
+    return shape !== undefined && recordTextCodecClass(shape) !== null;
+};
+const textDecoderLeaf = (t, tables) => {
+    if (t.kind !== "record")
+        return false;
+    const shape = tables.records.get(t.shapeId);
+    return shape !== undefined && recordTextCodecClass(shape) === "TextDecoder";
+};
+/** Whether converting a value of type `t` to or from dyn converts a
+ * TextEncoder or TextDecoder record, which boxes it as a handle of
+ * scr_text_codec_dyn.c (the same carrier walk as dgram sockets). */
+function mentionsTextCodec(t, tables) {
+    tables.textCodecCarriers ??= leafCarriers(tables, textCodecLeaf);
+    return carriesLeaf(t, tables.textCodecCarriers, textCodecLeaf, tables);
+}
+/** The TextDecoder half: its boxed decode runs scr_text_decode_stream,
+ * which reaches the legacy decoders. */
+function mentionsTextDecoder(t, tables) {
+    tables.textDecoderCarriers ??= leafCarriers(tables, textDecoderLeaf);
+    return carriesLeaf(t, tables.textDecoderCarriers, textDecoderLeaf, tables);
 }
 /** The libCall fns served by the OPTIONAL events unit (scr_events.c):
  * process signal/exit listeners and the piped-stdin surface. */
@@ -498,6 +591,83 @@ const STDIO_EXTENDED_NAMES = new Set(["setEncoding", "resize"]);
 const rule = (r) => r;
 /* The HTTP, HTTPS, HTTP/2 and TLS surfaces, which link the net unit. */
 const NET_PREFIXES = ["net.", "http.", "tls.", "https.", "http2."];
+/** The scr_dh.c entry points (the dh unit). */
+export const DH_LIB_FNS = new Set([
+    "crypto.dhNew",
+    "crypto.dhGroupNew",
+    "crypto.checkPrimeSync",
+    "crypto.checkPrimeCb",
+    "crypto.generatePrimeSync",
+    "crypto.generatePrimeCb",
+]);
+/** The scr_pki.c entry points (the pki unit). */
+export const PKI_LIB_FNS = new Set([
+    "crypto.createPrivateKey",
+    "crypto.createPublicKey",
+    "crypto.createSign",
+    "crypto.createVerify",
+    "crypto.generateKeyPairCb",
+    "crypto.generateKeyPairSync",
+    "crypto.signOneshot",
+    "crypto.verifyOneshot",
+]);
+/** The WebCrypto algorithms scr_webcrypto_pki.c implements over the pki
+ * unit (lowercased). */
+const WEBCRYPTO_ASYMMETRIC_NAMES = new Set([
+    "ecdsa",
+    "ed25519",
+    "rsa-pss",
+    "rsassa-pkcs1-v1_5",
+]);
+/** Whether a string literal in the module names Ed25519, without regard
+ * to case ("ed25519" for node:crypto, "Ed25519" for WebCrypto): the
+ * Ed25519 unit links then, alongside the pki unit. */
+function ed25519NameScan() {
+    let named = false;
+    return {
+        expr: (node) => {
+            if (!named && node.kind === "strLit" && node.value.toLowerCase() === "ed25519")
+                named = true;
+        },
+        result: () => named,
+    };
+}
+/** moduleUsesWebCryptoAsymmetric's condition as a runtime-feature scan. */
+function webCryptoAsymmetricScan() {
+    let webcrypto = false;
+    let named = false;
+    return {
+        expr: (node) => {
+            if (node.kind === "libCall" && node.fn.startsWith("webcrypto."))
+                webcrypto = true;
+            else if (!named &&
+                node.kind === "strLit" &&
+                WEBCRYPTO_ASYMMETRIC_NAMES.has(node.value.toLowerCase()))
+                named = true;
+        },
+        result: () => webcrypto && named,
+    };
+}
+/** Whether the module calls WebCrypto and a string literal in it names one
+ * of the asymmetric algorithms (matched without regard to case, as
+ * normalizeAlgorithm matches names): scr_webcrypto_pki.c and the pki unit
+ * link then. */
+export function moduleUsesWebCryptoAsymmetric(mod) {
+    let webcrypto = false;
+    let named = false;
+    everyModuleNode(mod, {
+        expr: (node) => {
+            if (node.kind === "libCall" && node.fn.startsWith("webcrypto."))
+                webcrypto = true;
+            if (node.kind === "strLit" && WEBCRYPTO_ASYMMETRIC_NAMES.has(node.value.toLowerCase()))
+                named = true;
+            return !(webcrypto && named);
+        },
+        stmt: () => !(webcrypto && named),
+        type: () => true,
+    });
+    return webcrypto && named;
+}
 /** One rule per runtime feature, sorted by name. A new feature is an
  * entry here and its line in noRuntimeFeatures; RuntimeFeatures, the scan
  * and its early exit derive from this table. The lists above keep one
@@ -524,8 +694,17 @@ const RUNTIME_FEATURE_RULES = {
     }),
     /** scr_cipher.c over the mbedTLS archive; DEP0182 reports through the
      * process-warning unit, and unknown output encodings render through the
-     * inspect unit. */
-    cipher: rule({ fns: ["crypto.cipherNew"] }),
+     * inspect unit. WebCrypto's encrypt, decrypt, wrapKey and unwrapKey
+     * (scr_webcrypto_aes.c) link the same archive. */
+    cipher: rule({
+        fns: [
+            "crypto.cipherNew",
+            "webcrypto.encrypt",
+            "webcrypto.decrypt",
+            "webcrypto.wrapKey",
+            "webcrypto.unwrapKey",
+        ],
+    }),
     copying: rule({
         expr: (node, _tables) => (node.kind === "arrIntrinsic" && COPYING_ARR_METHODS.has(node.method)) ||
             (node.kind === "bytesIntrinsic" && COPYING_BYTES_METHODS.has(node.method)),
@@ -540,6 +719,14 @@ const RUNTIME_FEATURE_RULES = {
         expr: (node, tables) => (node.kind === "dynFrom" && mentionsDgramSocket(node.value.type, tables())) ||
             (node.kind === "dynCheck" && mentionsDgramSocket(node.type, tables())),
     }),
+    /** A TextEncoder or TextDecoder record converts to or from an untyped
+     * value (its handle box, or a boxed function, record or collection that
+     * carries one): scr_text_codec_dyn.c. */
+    textCodecDyn: rule({
+        fns: ["text.codecIs"],
+        expr: (node, tables) => (node.kind === "dynFrom" && mentionsTextCodec(node.value.type, tables())) ||
+            (node.kind === "dynCheck" && mentionsTextCodec(node.type, tables())),
+    }),
     /** node:dns/promises: scr_dns_promises.c over the dgram unit. */
     dnsPromises: rule({ fns: ["dns.promisesLookup", "dns.promisesLookupService"] }),
     dynAsync: rule({
@@ -547,12 +734,17 @@ const RUNTIME_FEATURE_RULES = {
             mod.functions.some((fn) => fn.async === true && fn.generator === undefined && fn.returnType.kind === "dyn"),
         // The legacy url functions, crypto.createCipheriv and
         // ecdh.setPublicKey emit their deprecation warnings through the
-        // dyn-async unit; scr_wasm.c boxes its handles and promises through it.
+        // dyn-async unit (WebCrypto's encrypt and decrypt link scr_cipher.c
+        // too); scr_wasm.c boxes its handles and promises through it.
         fns: [
             ...DYN_ASYNC_LIB_FNS,
             ...READABLE_DYN_ASYNC_LIB_FNS,
             ...LEGACY_URL_LIB_FNS,
             "crypto.cipherNew",
+            "webcrypto.encrypt",
+            "webcrypto.decrypt",
+            "webcrypto.wrapKey",
+            "webcrypto.unwrapKey",
             "crypto.ecdhNew",
         ],
         prefixes: [...READABLE_DYN_ASYNC_PREFIXES, "wasm."],
@@ -599,12 +791,16 @@ const RUNTIME_FEATURE_RULES = {
     }),
     /** Own properties JavaScript adds to children (scr_dyn_handle_props.c). */
     handleProps: rule({ fns: ["child.propsInstall"] }),
+    /** The declaration-typed boundary's adoption (scr_decl_adopt.c): its
+     * casts, and closures boxed in a boundary program, which adopt their
+     * arguments. */
+    declAdopt: rule({ fns: ["dyn.declAdopt"], initial: (mod) => mod.declBoundary === true }),
     /** for await over checked-dynamic values (scr_dyn_for_await.c). */
     dynForAwait: rule({ fns: ["dyn.asyncIteratorOpen", "dyn.asyncIteratorWasSync"] }),
-    /** Fixed-width Buffer read/write methods called on checked-dynamic
-     * values (scr_bytes_dyn.c). */
-    dynBufferNum: rule({
-        expr: (node, _tables) => node.kind === "dynInvoke" && DYN_BUFFER_NUM_METHODS.has(node.method),
+    /** Buffer.prototype methods called on checked-dynamic values
+     * (scr_bytes_dyn.c). */
+    dynBuffer: rule({
+        expr: (node, _tables) => node.kind === "dynInvoke" && DYN_BUFFER_METHODS.has(node.method),
     }),
     /** Builtin functions read as values (scr_builtin_values.c). */
     builtinValues: rule({ fns: ["buffer.byteLenValue", "buffer.allocValue", "fs.realpathValue"] }),
@@ -614,6 +810,10 @@ const RUNTIME_FEATURE_RULES = {
      * process-warning unit, and unknown encodings and formats render through
      * the inspect unit. */
     ecdh: rule({ fns: ["crypto.ecdhNew", "crypto.ecdhConvertKey"] }),
+    /** scr_dh.c over the mbedTLS archive, also for checkPrime and
+     * generatePrime; unknown encodings and argument values render through
+     * the inspect unit. */
+    dh: rule({ fns: [...DH_LIB_FNS] }),
     emitter: rule({
         initial: (mod) => mod.workers === true || (mod.classes ?? []).some((c) => c.name === RUNTIME_EMITTER_CLASS),
         fns: [...STREAM_LIB_FNS, ...BUILTIN_CLASS_LIB_FNS],
@@ -653,15 +853,24 @@ const RUNTIME_FEATURE_RULES = {
             "global.native",
             "util.styleText",
             "crypto.cipherNew",
+            "webcrypto.encrypt",
+            "webcrypto.decrypt",
+            "webcrypto.wrapKey",
+            "webcrypto.unwrapKey",
             "crypto.ecdhNew",
             "crypto.ecdhConvertKey",
+            ...DH_LIB_FNS,
             ...BUILTIN_CLASS_LIB_FNS,
             ...UTIL_CALLABLE_LIB_FNS,
         ],
         prefixes: ["insp.", "console.", "test."],
         libCall: (node) => node.fn === "rl.terminal" && !isDynUndefined(node.args[3]),
     }),
-    legacyTextDecoder: rule({ fns: [...LEGACY_TEXT_DECODER_LIB_FNS] }),
+    legacyTextDecoder: rule({
+        fns: [...LEGACY_TEXT_DECODER_LIB_FNS],
+        expr: (node, tables) => (node.kind === "dynFrom" && mentionsTextDecoder(node.value.type, tables())) ||
+            (node.kind === "dynCheck" && mentionsTextDecoder(node.type, tables())),
+    }),
     /** The program calls mock.timers members: its timer calls go through
      * scr_test.c's mock-aware entry points. */
     mockTimers: rule({ prefixes: ["test.mockTimers", "test.ctxMockTimers"] }),
@@ -685,6 +894,12 @@ const RUNTIME_FEATURE_RULES = {
     /** perf_hooks event-loop metrics (eventLoopUtilization,
      * monitorEventLoopDelay): scr_perf_loop.c. */
     perfLoop: rule({ fns: ["perf.idleTime"], prefixes: ["perf.loop", "perf.eld"] }),
+    /** scr_pki.c over the mbedTLS archive: asymmetric KeyObjects and
+     * signatures. */
+    pki: rule({ scan: webCryptoAsymmetricScan, fns: [...PKI_LIB_FNS] }),
+    /** scr_ed25519.c (the vendored libsodium Ed25519), linked with pki: a
+     * string literal in the module names Ed25519. */
+    ed25519: rule({ scan: ed25519NameScan }),
     processEvents: rule({ fns: [...PROCESS_EVENT_LIB_FNS, "util.styleText"], types: ["procStream"] }),
     /** scr_url_legacy.c parses and stringifies queries. */
     qs: rule({ fns: [...QS_LIB_FNS, ...LEGACY_URL_LIB_FNS] }),
@@ -761,6 +976,7 @@ function noRuntimeFeatures() {
         dc: false,
         dgram: false,
         dgramDyn: false,
+        textCodecDyn: false,
         dnsPromises: false,
         dynAsync: false,
         dynBuiltinClass: false,
@@ -768,6 +984,7 @@ function noRuntimeFeatures() {
         dynInvoke: false,
         dynTier: false,
         ecdh: false,
+        dh: false,
         emitter: false,
         eventTarget: false,
         eventsOnceSignal: false,
@@ -784,6 +1001,8 @@ function noRuntimeFeatures() {
         nodeTest: false,
         parseArgs: false,
         perfLoop: false,
+        pki: false,
+        ed25519: false,
         processEvents: false,
         qs: false,
         regex: false,
@@ -792,8 +1011,9 @@ function noRuntimeFeatures() {
         stream: false,
         streamDyn: false,
         handleProps: false,
+        declAdopt: false,
         dynForAwait: false,
-        dynBufferNum: false,
+        dynBuffer: false,
         builtinValues: false,
         symbol: false,
         tls: false,
@@ -836,12 +1056,15 @@ for (const name of RUNTIME_FEATURE_NAMES) {
     if (rule.expr)
         FEATURE_EXPR_TESTS.push(name);
 }
-function scanRuntimeFeatures(mod, stopAt) {
+function scanRuntimeFeatures(mod, stopAt, nodes) {
     const features = noRuntimeFeatures();
+    const scans = [];
     for (const name of RUNTIME_FEATURE_NAMES) {
-        const initial = ruleOf(name).initial;
+        const { initial, scan } = ruleOf(name);
         if (initial && initial(mod))
             features[name] = true;
+        if (scan)
+            scans.push({ name, scan: scan() });
     }
     const keepGoing = () => stopAt === undefined || !features[stopAt];
     let tables;
@@ -851,6 +1074,8 @@ function scanRuntimeFeatures(mod, stopAt) {
         classes: new Map((mod.classes ?? []).map((c) => [c.name, c])),
     });
     const expr = (node) => {
+        for (let i = 0; i < scans.length; i++)
+            scans[i].scan.expr(node);
         if (node.kind === "libCall") {
             const fn = node.fn;
             for (const name of FEATURES_BY_FN.get(fn) ?? [])
@@ -874,8 +1099,24 @@ function scanRuntimeFeatures(mod, stopAt) {
             features[name] = true;
         return keepGoing();
     };
-    if (keepGoing())
+    // Each condition is a fact about one expression or one type (the rule
+    // scans combine such facts in no particular order), so the index's
+    // expressions and distinct types answer as the walk does. An early stop
+    // (stopAt) keeps the walk.
+    if (nodes !== undefined && stopAt === undefined) {
+        const expressions = nodes.expressions();
+        for (const fn of mod.functions)
+            eachNodeOfKinds(fn, expressions, (node) => {
+                expr(node);
+            });
+        for (const t of nodes.types)
+            type(t);
+    }
+    else if (keepGoing())
         everyModuleNode(mod, { expr, stmt: keepGoing, type });
+    for (const { name, scan } of scans)
+        if (scan.result())
+            features[name] = true;
     // Inline-cache sites of dynamic-tier functions use the tier's shapes
     // (scr_js_object.c, with the SCR_JS_TIER build of scr_json.c).
     if (!features.dynTier && mod.functions.some((fn) => fn.tier === "dynamic")) {