@scriptc/compiler 0.1.5 → 0.1.7

package/dist/frontend/program.test.js

@@ -0,0 +1,117 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect, test } from "vitest";
+import { checkPreflight, loadProgram } from "./program.js";
+function requireOrderDiagnostics(source, dependency = "exports.value = 'ready';\n") {
+    const dir = mkdtempSync(join(tmpdir(), "scriptc-require-order-"));
+    const entry = join(dir, "main.cjs");
+    writeFileSync(entry, source);
+    writeFileSync(join(dir, "dep.cjs"), dependency);
+    const load = loadProgram(entry);
+    try {
+        return checkPreflight(load);
+    }
+    finally {
+        load.dispose();
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+test.for([
+    "exports.read = read;",
+    "module.exports.renamed = read;",
+    "module.exports = read;",
+])("a hoisted function export before require is safe: %s", (publish) => {
+    expect(requireOrderDiagnostics(`
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+${publish}
+const dep = require('./dep.cjs');
+function read() { return helper(); }
+function helper() { return dep.value; }
+`)).toEqual([]);
+});
+test.for([
+    "exports.a = exports.b = void 0;",
+    "exports.a = undefined; exports.b = 'literal'; exports.c = 1;",
+    "exports.first = exports.second = read;",
+])("literal and chained export prologues do not invoke functions: %s", (prefix) => {
+    expect(requireOrderDiagnostics(`
+Object.defineProperty(exports, '__esModule', { value: true });
+${prefix}
+exports.read = read;
+const dep = require('./dep.cjs');
+function read() { return dep.value; }
+`)).toEqual([]);
+});
+test.for([
+    ["direct call", "read();"],
+    ["transitive call", "helper(); function helper() { return read(); }"],
+    ["callback escape", "[1].map(read);"],
+    ["export call", "exports.read();"],
+    ["export alias call", "const alias = exports; alias.read();"],
+    ["computed export name", "exports[read()] = read;"],
+    ["export initializer call", "exports.value = read();"],
+    ["class static initializer", "class Early { static value = read(); }"],
+    ["extra descriptor effect", "Object.defineProperty(exports, '__esModule', { value: true, enumerable: read() });"],
+    ["void initializer call", "exports.value = void read();"],
+    ["prototype mutation", "exports.__proto__ = read;"],
+    ["read-only marker", "Object.defineProperty(exports, '__esModule', { value: true }); exports.__esModule = read;"],
+    ["replacement export property", "module.exports = read; module.exports.name = read;"],
+    ["non-export assignment chain", "const box = {}; exports.alias = box.read = read;"],
+])("require still refuses an early read through %s", ([, early]) => {
+    const diagnostics = requireOrderDiagnostics(`
+exports.read = read;
+${early}
+const dep = require('./dep.cjs');
+function read() { return dep.value; }
+`);
+    expect(diagnostics.some((diag) => diag.code === "SC1013" && diag.message.includes("binding 'dep'")))
+        .toBe(true);
+});
+test("publishing a require binding itself still reads it before initialization", () => {
+    const diagnostics = requireOrderDiagnostics(`
+exports.read = read;
+const { read } = require('./dep.cjs');
+`);
+    expect(diagnostics.some((diag) => diag.code === "SC1013" && diag.message.includes("binding 'read'")))
+        .toBe(true);
+});
+test.for([
+    "var Object = null; Object.defineProperty(exports, '__esModule', { value: true }); exports.read = read;",
+    "var exports = null; exports.read = read;",
+    "var module = null; module.exports = read;",
+])("source bindings cannot masquerade as a CommonJS prologue: %s", (prefix) => {
+    const diagnostics = requireOrderDiagnostics(`
+${prefix}
+const dep = require('./dep.cjs');
+function read() { return dep.value; }
+`);
+    expect(diagnostics.some((diag) => diag.code === "SC1013" && diag.message.includes("binding 'dep'")))
+        .toBe(true);
+});
+test("an earlier declarator can call an export before the require initializes", () => {
+    const diagnostics = requireOrderDiagnostics(`
+exports.read = read;
+const before = read(), dep = require('./dep.cjs');
+function read() { return dep.value; }
+`);
+    expect(diagnostics.some((diag) => diag.code === "SC1013" && diag.message.includes("binding 'dep'")))
+        .toBe(true);
+});
+test("a later declarator can call an export after the require initializes", () => {
+    expect(requireOrderDiagnostics(`
+exports.read = read;
+const dep = require('./dep.cjs'), after = read();
+function read() { return dep.value; }
+`)).toEqual([]);
+});
+test("function publication does not admit CommonJS cycles", () => {
+    const diagnostics = requireOrderDiagnostics(`
+exports.read = read;
+const dep = require('./dep.cjs');
+function read() { return dep.value; }
+`, "const main = require('./main.cjs'); exports.value = main.read();\n");
+    expect(diagnostics.some((diag) => diag.code === "SC1016")).toBe(true);
+});
+//# sourceMappingURL=program.test.js.map

package/dist/frontend/program.test.js.map

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

package/dist/frontend/type-mapper.d.ts

@@ -155,8 +155,10 @@ export declare class UnionRegistry {
 }
 /** Human-readable rendering of an IrType for diagnostics (records expand to
  * their canonical field list, unions to their arms; `checker.typeToString`
- * can't — it never sees IR types). `seen` breaks recursive shapes/unions:
- * a back-reference renders as "..." instead of expanding forever. */
+ * can't — it never sees IR types). Bound the traversal as well as its output:
+ * cycle detection alone still expands a shared acyclic graph exponentially.
+ * The same budget covers every sibling, and deep wrapper chains truncate
+ * before exhausting the JS stack. Small types retain their full spelling. */
 export declare function formatIrType(t: IrType, shapes: ShapeRegistry, unions: UnionRegistry, seen?: Set<string>): string;
 /** True when a type contains a record anywhere (the trigger for the
  * shape-mismatch diagnostic SC2002 — non-record mismatches are tsc's or

package/dist/frontend/type-mapper.js

@@ -1,5 +1,6 @@
 import { InternalCompilerError } from "../errors.js";
 import * as ts from "./ts7/adapter.js";
+import { bodyReadsArguments } from "./arguments-usage.js";
 import { arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, UNDEFINED_T, VOID } from "../ir/ir.js";
 import { BIGINT_T } from "../ir/ir.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
@@ -32,6 +33,14 @@ export const ISLAND_AMBIENT_TYPES = [
     "ReadableStreamReadValueResult",
     "ReadableStreamReadDoneResult",
 ];
+function isAmbientAbortHandleType(type, ctx) {
+    if (type.isUnionType())
+        return ts.constituentTypes(type).some((part) => isAmbientAbortHandleType(part, ctx));
+    const symbol = type.getSymbol();
+    return !!symbol &&
+        (symbol.name === "AbortSignal" || symbol.name === "AbortController") &&
+        ctx.checker.declarationsOf(symbol).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) && ctx.isStdlibFile(d.getSourceFile()));
+}
 /** node:util.parseArgs's public and @types/node helper type names. Values
  * behind this surface use the checked-dynamic tree; see mapTypeInner. */
 const PARSE_ARGS_DYN_TYPES = new Set([
@@ -368,165 +377,244 @@ export class UnionRegistry {
 }
 /** Human-readable rendering of an IrType for diagnostics (records expand to
  * their canonical field list, unions to their arms; `checker.typeToString`
- * can't — it never sees IR types). `seen` breaks recursive shapes/unions:
- * a back-reference renders as "..." instead of expanding forever. */
+ * can't — it never sees IR types). Bound the traversal as well as its output:
+ * cycle detection alone still expands a shared acyclic graph exponentially.
+ * The same budget covers every sibling, and deep wrapper chains truncate
+ * before exhausting the JS stack. Small types retain their full spelling. */
 export function formatIrType(t, shapes, unions, seen = new Set()) {
-    switch (t.kind) {
-        case "f64":
-            return "number";
-        case "string":
-            return "string";
-        case "bool":
-            return "boolean";
-        case "dyn":
-            return "unknown";
-        case "caught":
-            // What tsc calls the binding; the fence messages carry the real story.
-            return "unknown";
-        case "void":
-            return "void";
-        case "undefinedT":
-            return "undefined";
-        case "nullT":
-            return "null";
-        case "array": {
-            // Union/func elements need the parens TS syntax would ("(number |
-            // string)[]" — without them the [] reads as binding to the last arm).
-            const elem = formatIrType(t.elem, shapes, unions, seen);
-            return t.elem.kind === "union" || t.elem.kind === "func" ? `(${elem})[]` : `${elem}[]`;
-        }
-        case "bytes":
-            // The u8 kind reads as Uint8Array (Buffer maps here too — one
-            // runtime representation; the message stays honest either way).
-            return t.elem === "u8" ? "Uint8Array" : t.elem === "u32" ? "Uint32Array" : t.elem === "i32" ? "Int32Array" : t.elem === "f32" ? "Float32Array" : "Float64Array";
-        case "map":
-            return `Map<${formatIrType(t.key, shapes, unions, seen)}, ${formatIrType(t.value, shapes, unions, seen)}>`;
-        case "set":
-            return `Set<${formatIrType(t.elem, shapes, unions, seen)}>`;
-        case "func":
-            return `(${t.params.map((p) => formatIrType(p, shapes, unions, seen)).join(", ")}) => ${formatIrType(t.ret, shapes, unions, seen)}`;
-        case "object":
-            // Runtime-provided error classes carry '%'-prefixed IR names
-            // ("%Error") so user classes can never collide; diagnostics show the
-            // source-level name.
-            return t.className.startsWith("%") ? t.className.slice(1) : t.className;
-        case "classval":
-            // The static side, in TS's own spelling.
-            return `typeof ${t.className.startsWith("%") ? t.className.slice(1) : t.className}`;
-        case "record": {
-            const shape = shapes.get(t.shapeId);
-            if (!shape)
-                return `{ /* unknown shape ${t.shapeId} */ }`;
-            if (seen.has(t.shapeId))
-                return "..."; // the recursive knot
-            seen.add(t.shapeId);
-            try {
-                if (shape.tuple) {
-                    const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
-                    return `[${byIndex.map((f) => formatIrType(f.type, shapes, unions, seen)).join(", ")}]`;
-                }
-                const members = shape.fields.map((f) => {
-                    // Accessor slots print in TS's accessor spelling, not the
-                    // reserved '%'-field encoding.
-                    const slot = accessorSlotProp(f.name);
-                    if (slot && f.type.kind === "func") {
-                        return slot.kind === "get"
-                            ? `get ${slot.prop}(): ${formatIrType(f.type.ret, shapes, unions, seen)}`
-                            : `set ${slot.prop}(${formatIrType(f.type.params[0] ?? VOID, shapes, unions, seen)})`;
+    const maxLength = 4096;
+    const maxDepth = 32;
+    let output = "";
+    let truncated = false;
+    const append = (text) => {
+        if (truncated)
+            return;
+        // Reserve the marker so a full buffer can always report truncation.
+        const remaining = maxLength - 3 - output.length;
+        if (text.length > remaining) {
+            output += text.slice(0, remaining) + "...";
+            truncated = true;
+        }
+        else {
+            output += text;
+        }
+    };
+    const list = (types, separator, depth) => {
+        for (let i = 0; i < types.length && !truncated; i++) {
+            if (i > 0)
+                append(separator);
+            visit(types[i], depth);
+        }
+    };
+    const visit = (t, depth) => {
+        if (truncated)
+            return;
+        if (depth >= maxDepth)
+            return append("...");
+        const child = (type) => visit(type, depth + 1);
+        switch (t.kind) {
+            case "f64":
+                return append("number");
+            case "string":
+                return append("string");
+            case "bool":
+                return append("boolean");
+            case "dyn":
+                return append("unknown");
+            case "caught":
+                // What tsc calls the binding; the fence messages carry the real story.
+                return append("unknown");
+            case "void":
+                return append("void");
+            case "undefinedT":
+                return append("undefined");
+            case "nullT":
+                return append("null");
+            case "array": {
+                // Union/func elements need the parens TS syntax would ("(number |
+                // string)[]" — without them the [] reads as binding to the last arm).
+                const parens = t.elem.kind === "union" || t.elem.kind === "func";
+                if (parens)
+                    append("(");
+                child(t.elem);
+                return append(parens ? ")[]" : "[]");
+            }
+            case "bytes":
+                // The u8 kind reads as Uint8Array (Buffer maps here too — one
+                // runtime representation; the message stays honest either way).
+                return append(t.elem === "u8" ? "Uint8Array" : t.elem === "u32" ? "Uint32Array" : t.elem === "i32" ? "Int32Array" : t.elem === "f32" ? "Float32Array" : "Float64Array");
+            case "map":
+                append("Map<");
+                child(t.key);
+                append(", ");
+                child(t.value);
+                return append(">");
+            case "set":
+                append("Set<");
+                child(t.elem);
+                return append(">");
+            case "func":
+                append("(");
+                list(t.params, ", ", depth + 1);
+                append(") => ");
+                return child(t.ret);
+            case "object":
+                // Runtime-provided error classes carry '%'-prefixed IR names
+                // ("%Error") so user classes can never collide; diagnostics show the
+                // source-level name.
+                return append(t.className.startsWith("%") ? t.className.slice(1) : t.className);
+            case "classval":
+                // The static side, in TS's own spelling.
+                append("typeof ");
+                return append(t.className.startsWith("%") ? t.className.slice(1) : t.className);
+            case "record": {
+                const shape = shapes.get(t.shapeId);
+                if (!shape)
+                    return append(`{ /* unknown shape ${t.shapeId} */ }`);
+                if (seen.has(t.shapeId))
+                    return append("..."); // the recursive knot
+                seen.add(t.shapeId);
+                try {
+                    if (shape.tuple) {
+                        const byIndex = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+                        append("[");
+                        for (let i = 0; i < byIndex.length && !truncated; i++) {
+                            if (i > 0)
+                                append(", ");
+                            child(byIndex[i].type);
+                        }
+                        return append("]");
+                    }
+                    if (shape.fields.length === 0 && !shape.indexValue)
+                        return append("{}");
+                    append("{ ");
+                    for (let i = 0; i < shape.fields.length && !truncated; i++) {
+                        if (i > 0)
+                            append("; ");
+                        const f = shape.fields[i];
+                        // Accessor slots print in TS's accessor spelling, not the
+                        // reserved '%'-field encoding.
+                        const slot = accessorSlotProp(f.name);
+                        if (slot && f.type.kind === "func") {
+                            append(slot.kind === "get" ? "get " : "set ");
+                            append(slot.prop);
+                            if (slot.kind === "get") {
+                                append("(): ");
+                                child(f.type.ret);
+                            }
+                            else {
+                                append("(");
+                                child(f.type.params[0] ?? VOID);
+                                append(")");
+                            }
+                        }
+                        else {
+                            append(f.name);
+                            append(": ");
+                            child(f.type);
+                        }
+                    }
+                    if (shape.indexValue) {
+                        if (shape.fields.length > 0)
+                            append("; ");
+                        append("[key: string]: ");
+                        child(shape.indexValue);
                     }
-                    return `${f.name}: ${formatIrType(f.type, shapes, unions, seen)}`;
-                });
-                if (shape.indexValue) {
-                    members.push(`[key: string]: ${formatIrType(shape.indexValue, shapes, unions, seen)}`);
+                    return append(" }");
+                }
+                finally {
+                    seen.delete(t.shapeId); // sibling occurrences still expand
                 }
-                if (members.length === 0)
-                    return "{}";
-                return `{ ${members.join("; ")} }`;
-            }
-            finally {
-                seen.delete(t.shapeId); // sibling occurrences still expand
             }
-        }
-        case "union": {
-            const def = unions.get(t.unionId);
-            if (!def)
-                return `/* union ${t.unionId} */`;
-            if (seen.has(t.unionId))
-                return "..."; // the recursive knot
-            seen.add(t.unionId);
-            try {
-                return def.arms.map((a) => formatIrType(a, shapes, unions, seen)).join(" | ");
+            case "union": {
+                const def = unions.get(t.unionId);
+                if (!def)
+                    return append(`/* union ${t.unionId} */`);
+                if (seen.has(t.unionId))
+                    return append("..."); // the recursive knot
+                seen.add(t.unionId);
+                try {
+                    return list(def.arms, " | ", depth + 1);
+                }
+                finally {
+                    seen.delete(t.unionId);
+                }
             }
-            finally {
-                seen.delete(t.unionId);
+            case "jsval":
+                return append("any");
+            case "regex":
+                return append("RegExp");
+            case "date":
+                return append("Date");
+            case "url":
+                return append("URL");
+            case "searchParams":
+                return append("URLSearchParams");
+            case "symbol":
+                return append("symbol");
+            case "bigint":
+                return append("bigint");
+            case "stats":
+                return append("Stats");
+            case "fileHandle":
+                return append("FileHandle");
+            case "spawnRes":
+                return append("SpawnSyncReturns");
+            case "child":
+                return append("ChildProcess");
+            case "netServer":
+                return append("Server");
+            case "netSocket":
+                return append("Socket");
+            case "http2Session":
+                return append("Http2Session");
+            case "http2Stream":
+                return append("Http2Stream");
+            case "dgramSocket":
+                return append("dgram.Socket");
+            case "testCtx":
+                return append("TestContext");
+            case "httpReq":
+                return append("IncomingMessage");
+            case "httpRes":
+                return append("ServerResponse");
+            case "httpClientReq":
+                return append("ClientRequest");
+            case "secureCtx":
+                return append("SecureContext");
+            case "cryptoHash":
+                return append("Hash");
+            case "cryptoHmac":
+                return append("Hmac");
+            case "fsWatcher":
+                return append("FSWatcher");
+            case "childStream":
+                return append("Readable");
+            case "childWriter":
+                return append("Writable");
+            case "procStream":
+                return append("WriteStream");
+            case "moduleNs":
+                append("module namespace '");
+                append(t.moduleId);
+                return append("'");
+            case "promise":
+                append("Promise<");
+                child(t.inner);
+                return append(">");
+            case "generator":
+                append(t.async ? "AsyncGenerator<" : "Generator<");
+                list([t.yieldT, t.retT, t.nextT], ", ", depth + 1);
+                return append(">");
+            default: {
+                const _exhaustive = t;
+                void _exhaustive;
+                throw new InternalCompilerError("unreachable");
             }
         }
-        case "jsval":
-            return "any";
-        case "regex":
-            return "RegExp";
-        case "date":
-            return "Date";
-        case "url":
-            return "URL";
-        case "searchParams":
-            return "URLSearchParams";
-        case "symbol":
-            return "symbol";
-        case "bigint":
-            return "bigint";
-        case "stats":
-            return "Stats";
-        case "fileHandle":
-            return "FileHandle";
-        case "spawnRes":
-            return "SpawnSyncReturns";
-        case "child":
-            return "ChildProcess";
-        case "netServer":
-            return "Server";
-        case "netSocket":
-            return "Socket";
-        case "http2Session":
-            return "Http2Session";
-        case "http2Stream":
-            return "Http2Stream";
-        case "dgramSocket":
-            return "dgram.Socket";
-        case "testCtx":
-            return "TestContext";
-        case "httpReq":
-            return "IncomingMessage";
-        case "httpRes":
-            return "ServerResponse";
-        case "httpClientReq":
-            return "ClientRequest";
-        case "secureCtx":
-            return "SecureContext";
-        case "cryptoHash":
-            return "Hash";
-        case "cryptoHmac":
-            return "Hmac";
-        case "fsWatcher":
-            return "FSWatcher";
-        case "childStream":
-            return "Readable";
-        case "childWriter":
-            return "Writable";
-        case "procStream":
-            return "WriteStream";
-        case "moduleNs":
-            return `module namespace '${t.moduleId}'`;
-        case "promise":
-            return `Promise<${formatIrType(t.inner, shapes, unions, seen)}>`;
-        case "generator":
-            return `${t.async ? "AsyncGenerator" : "Generator"}<${formatIrType(t.yieldT, shapes, unions, seen)}, ${formatIrType(t.retT, shapes, unions, seen)}, ${formatIrType(t.nextT, shapes, unions, seen)}>`;
-        default: {
-            const _exhaustive = t;
-            void _exhaustive;
-            throw new InternalCompilerError("unreachable");
-        }
-    }
+    };
+    visit(t, 0);
+    return output;
 }
 /** True when the declaration sits inside `declare module "<name>"` (or
  * its node:-prefixed twin) — the disambiguator for builtin-module type
@@ -602,28 +690,6 @@ export function containsUnion(t) {
             return false;
     }
 }
-/** lower-calls.ts's bodyReadsArguments, duplicated here (type-mapper.ts must not
- * import from lowering/ — that edge is a module cycle): does the function's
- * OWN body read `arguments`? Nested plain functions/methods own theirs
- * (skipped); arrows see the enclosing one (descended). */
-function bodyReadsArgumentsLocal(fn) {
-    let found = false;
-    if (fn.body === undefined)
-        return false;
-    // Iterative walk (walkPreorder): function bodies can hold pathologically
-    // deep expression chains that a recursive visit would die on.
-    ts.walkPreorder(fn.body, (n) => {
-        if (ts.isIdentifier(n) && n.text === "arguments" && !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n)) {
-            found = true;
-            return "stop";
-        }
-        if ((ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n)) && n !== fn) {
-            return "skip"; // own `arguments` scope
-        }
-        return undefined;
-    });
-    return found;
-}
 /** A generator type's normalized value channels (Generator<T, TReturn,
  * TNext> and the IteratorResult alias share this):
  * - yield: `never` (a generator that never yields) rides the VOID
@@ -1084,8 +1150,8 @@ function mapTypeInner(type, ctx) {
             // plumbing, values arrive dyn or convert via dynFrom.
             if (!et || et.kind === "void")
                 return null;
-            // A jsval MEMBER absorbs the tuple (bare jsval fields have no shape
-            // slot — the record-field rule), exactly like record fields below.
+            // A jsval member keeps this tuple in the island as a real JS array.
+            // Object records may instead keep ambient abort handles in slots.
             if (et.kind === "jsval")
                 return JSVAL;
             fields.push({ name: String(i), type: et });
@@ -2228,7 +2294,7 @@ function mapTypeInner(type, ctx) {
             // tsgo never SYNTHESIZES that rest param into the inferred signature
             // (5.9.3 did — the count mismatch above was the whole detector
             // there), so the declaration's own body answers directly.
-            if (sigDecl !== undefined && ts.isFunctionLike(sigDecl) && bodyReadsArgumentsLocal(sigDecl)) {
+            if (sigDecl !== undefined && ts.isFunctionLike(sigDecl) && bodyReadsArguments(sigDecl)) {
                 return null;
             }
         }
@@ -3415,14 +3481,11 @@ function mapRecordTypeInner(widened, ctx) {
             // accessor dispatch, so the shape stays unmapped.
             if (accessorSlotProp(p.name) !== null)
                 return null;
-            // A bare jsval FIELD absorbs the record: shapes have no handle slot
-            // (the IR forbids jsval fields — no JSON story), while an island
-            // OBJECT holds engine values natively — `{ model: gateway(id),
-            // prompt }` is one island object, built field by field (jsval
-            // members as the same handle, static members marshaled). jsval-
-            // BEARING composite fields (`content: any[]`) keep their static
-            // shape — the lift covers them.
-            if (pt.kind === "jsval")
+            // Keep ambient abort handles in a native record slot under --dynamic:
+            // an options record with `signal?: AbortSignal` must not turn its
+            // unrelated static fields into island properties. Other bare jsval
+            // fields still absorb the record into one island object.
+            if (pt.kind === "jsval" && !(ctx.dynamic && isAmbientAbortHandleType(fieldTs, ctx)))
                 return JSVAL;
             fields.push({ name: p.name, type: pt });
         }
@@ -3623,7 +3686,7 @@ export function describeComponentBlocker(widened, ctx) {
         if (sigDecl !== undefined &&
             ts.isFunctionLike(sigDecl) &&
             (sigDecl.parameters.length !== sig.getParameters().length ||
-                bodyReadsArgumentsLocal(sigDecl))) {
+                bodyReadsArguments(sigDecl))) {
             return `the function shape is supported, but its signature is variadic ('arguments'-reading), and a compiled signature is fixed-arity`;
         }
         for (const p of sig.getParameters()) {