@scriptc/compiler 0.0.7 → 0.0.9

package/dist/ir/nodes.d.ts

@@ -243,6 +243,7 @@ export type IrType = {
     params: IrType[];
     ret: IrType;
     rest?: true;
+    restAbi?: "jsval";
 } | {
     kind: "object";
     className: string;
@@ -436,8 +437,16 @@ export declare function isSupportedMapValue(t: IrType): boolean;
 /** The INDEX-SIGNATURE value fence (`{ [k: string]: V }` shapes): the map
  * VALUE kinds — the overflow portion IS a string-keyed map — plus dyn
  * (`unknown`, an unknown-valued pricing-table shape: overflow reads surface ordinary
- * dyn values validated by the usual checked casts). Shared frontend
- * (mapType) / validator. */
+ * dyn values validated by the usual checked casts) and three kinds the
+ * overflow store carries that user Maps don't admit yet:
+ *   func — `Record<string, () => void>`, the command-registry pattern
+ *          (scr_closure adapters; closures are cycle-headered and traced,
+ *          so a handler capturing its own registry collects)
+ *   map/set — `Record<string, Map<K, V>>`/`Record<string, Set<T>>`
+ *          nested-container tables (scr_map adapters; a map value's own
+ *          cycle capability propagates through the trace fixpoint)
+ * Nested index-signature RECORDS ride the record kind like any other.
+ * Shared frontend (mapType) / validator. */
 export declare function isSupportedIndexValue(t: IrType): boolean;
 export declare function funcOf(params: IrType[], ret: IrType): IrType;
 /** The union FUNC/SET-arm sibling rule, shared by the frontend's union
@@ -542,6 +551,24 @@ export interface IrLibExport {
     fnName: string;
     params: ("f64" | "bool" | "string" | "bytes" | "u8" | "u32" | "i32")[];
     returns: "f64" | "bool" | "string" | "bytes" | "void";
+    /** The exact sink-message bytes this wrapper passes to the inbound-bytes
+     * marshalling helper's trap — present exactly when a parameter is
+     * bytes-classed. Already the assembled structured trap-teaching form
+     * (library/trap-teaching.ts): 0x01, teaching text, 0x1F, SC4012, 0x1F,
+     * this export's C symbol, and the profile's remediation behind one more
+     * 0x1F when supplied. Assembled ONCE at export resolution so both
+     * backends emit identical bytes by construction. */
+    inboundBytesTrap?: string;
+}
+/** One runtime-trap overlay row: the profile's teaching (replaces the
+ * baseline human line as field 0) and/or remediation (the optional fourth
+ * field) for one runtime detected-trap code. At least one of the two is
+ * present, or the row is not emitted. Text is profile-validated free of
+ * the encoding's reserved bytes (SC4001). */
+export interface IrLibTrapOverlay {
+    code: string;
+    teaching?: string;
+    remediation?: string;
 }
 export interface IrLibSection {
     /** The profile's identity string (artifact header comments only). */
@@ -557,6 +584,15 @@ export interface IrLibSection {
      * posture (every entry prologue resets the arena). */
     resultResetSymbol: string | null;
     exports: IrLibExport[];
+    /** Profile-declared teaching/remediation overlays for the runtime
+     * detected-trap code family (SC4013–SC4019, diagnostics registry): both
+     * backends emit these as the program TU's overlay table
+     * (scr_library_trap_overlays — flat code/teaching/remediation triples)
+     * that the library trap funnel consults when it assembles a detected
+     * trap's structured sink message. Only declared codes appear, in the
+     * registry family's order, so the two emissions' data is identical by
+     * construction. */
+    trapOverlays: IrLibTrapOverlay[];
     /** The ask-2 identity getters (present exactly when the profile
      * declares a sidecar): pure data returns emitted with NO entry
      * prologue — exempt from the poisoned guard and every runtime touch
@@ -1162,7 +1198,12 @@ export type IrStrIntrinsicMethod = "length" | "charCodeAt" | "charAt" | "indexOf
  * DataView" RangeError on any bad offset. `dvGetBigUint64Number`/
  * `dvGetBigInt64Number` are the COMPOSED `Number(view.getBigUint64(...))`
  * lowerings — the bare bigint-returning calls are fenced, the wrapped
- * form converts the 8-byte integer to double exactly as Number(bigint). */
+ * form converts the 8-byte integer to double exactly as Number(bigint).
+ * The `dvSet*` setters mirror the getters: [offset, value] plus the
+ * optional bool littleEndian on the multi-byte kinds → void, the same
+ * constant RangeError on any bad offset; values coerce JS-exactly
+ * (integer kinds by modular truncation, Float32 by double→float
+ * rounding). No BIG setters exist — bigint arguments never lower. */
 export type IrBytesIntrinsicMethod = "length" | "byteLength" | "get" | "slice" | "setFrom" | "toString" | "readNum" | "writeNum" | "readNumVar" | "writeNumVar"
 /** The comparison/search/mutation surface (u8 receivers only; see the
  * runtime contract): `equals` [bytes] → bool (never throws);
@@ -1178,7 +1219,7 @@ export type IrBytesIntrinsicMethod = "length" | "byteLength" | "get" | "slice" |
  * f64 copied count, THROWS; `swap16/32/64` [] → the receiver (+1,
  * in-place), THROW; `writeStr` [string, strLit enc, f64 offset, f64
  * length?] → f64 bytes written, THROWS. */
- | "equals" | "compareBuf" | "indexOf" | "lastIndexOf" | "includes" | "indexOfNum" | "lastIndexOfNum" | "includesNum" | "fill" | "fillNum" | "fillStr" | "copy" | "swap16" | "swap32" | "swap64" | "writeStr" | "byteOffset" | "dataViewNew" | "dvGetUint8" | "dvGetInt8" | "dvGetUint16" | "dvGetInt16" | "dvGetUint32" | "dvGetInt32" | "dvGetFloat32" | "dvGetFloat64" | "dvGetBigUint64Number" | "dvGetBigInt64Number";
+ | "equals" | "compareBuf" | "indexOf" | "lastIndexOf" | "includes" | "indexOfNum" | "lastIndexOfNum" | "includesNum" | "fill" | "fillNum" | "fillStr" | "copy" | "swap16" | "swap32" | "swap64" | "writeStr" | "byteOffset" | "dataViewNew" | "dvGetUint8" | "dvGetInt8" | "dvGetUint16" | "dvGetInt16" | "dvGetUint32" | "dvGetInt32" | "dvGetFloat32" | "dvGetFloat64" | "dvGetBigUint64Number" | "dvGetBigInt64Number" | "dvSetUint8" | "dvSetInt8" | "dvSetUint16" | "dvSetInt16" | "dvSetUint32" | "dvSetInt32" | "dvSetFloat32" | "dvSetFloat64";
 /** The bytesIntrinsic methods that can raise a catchable error — backends'
  * may-throw analyses seed on these exactly like MAY_THROW_LIB_FNS. */
 export declare const MAY_THROW_BYTES_METHODS: ReadonlySet<IrBytesIntrinsicMethod>;
@@ -1425,6 +1466,20 @@ export type IrLibFn = "island.eval"
  * result for negative fractions rounding to zero. The explicit-digits
  * forms keep their island lowering. Results +1; never throw. */
  | "num.toExponential" | "num.toFixed0"
+/** Object.is over two numbers — the spec's SameValue on doubles: NaN
+ * equals NaN, +0 differs from -0, everything else is `===`. Plain bool
+ * result; never throws. (Union-armed operands take unionEq's sameValue
+ * flag instead — this is the both-f64 fast path.) */
+ | "num.sameValue"
+/** `new Intl.NumberFormat("en-US").format(x)` and
+ * `x.toLocaleString("en-US")` with DEFAULT options — the one locale
+ * whose data the runtime embeds (Node's default-build locale): decimal
+ * notation, 0–3 fraction digits rounded half-up on the SHORTEST
+ * round-tripping decimal (ICU's rounding input, probed vs Node —
+ * format(1.0005) is "1.001" though toFixed(3) answers "1.000"), ","
+ * grouping every three integer digits, "∞"/"NaN" texts, and "-0" for
+ * negative inputs rounding to zero. Result +1; never throws. */
+ | "intl.numFormatEnUs"
 /** `delete process.env[NAME]` — unsetenv(3): the mutation is visible to
  * every later read (process.envGet asks getenv fresh) and inherited by
  * spawned children, exactly Node. Statement position only (JS's boolean
@@ -1952,6 +2007,37 @@ export type IrLibFn = "island.eval"
  * zero-padded to the total. THROWS Node's 'length' RangeError on a
  * negative/non-integer total (may-throw seed). */
  | "buffer.concatLen"
+/** The checked-dynamic compare/equals validators (scr_bytes_io.c) —
+ * the lowered form when an argument is NOT statically bytes<u8> (the
+ * invalid-input probes; a dyn from an untyped JS helper): Node's own
+ * argument ladders run at runtime — ERR_INVALID_ARG_TYPE with the
+ * API's argument name ("buf1"/"buf2", "otherBuffer", "target"; offsets
+ * "of type number"), validateOffset's ERR_OUT_OF_RANGE for bad
+ * numbers, undefined offsets taking their Node defaults — and a
+ * well-typed value still computes the real answer. All args borrowed
+ * dyn; compareChk's four offset slots pass the undefined dyn when
+ * syntactically absent. May-throw seeds. */
+ | "buffer.compareChk" | "bytes.equalsChk" | "bytes.compareChk"
+/** The deprecated `new Buffer(number, 'enc')` string-arm rejection:
+ * always throws Node's ERR_INVALID_ARG_TYPE ("The \"string\" argument
+ * must be of type string. Received ..."). Borrowed dyn; may-throw. */
+ | "buffer.newStringFail"
+/** fs._toUnixTimestamp(time) over a DOM value: numeric strings and
+ * finite numbers coerce (negatives answer now/1000, Node's shape);
+ * everything else throws Node's ERR_INVALID_ARG_TYPE. May-throw. */
+ | "fs.toUnixTimestamp"
+/** The compiler-resolved ERR_INVALID_ARG_TYPE throw with a RUNTIME-
+ * rendered Received tail: args [argname, "of type ..." clause, the
+ * offending DOM value]. ALWAYS THROWS; polymorphic result (the
+ * error.nodeThrow pattern). May-throw seed. */
+ | "error.argTypeThrow"
+/** The checked-dynamic max-listeners ladders: setMaxChk is the
+ * instance form over a DOM n (non-numbers ERR_INVALID_ARG_TYPE,
+ * negatives/NaN ERR_OUT_OF_RANGE; +1 receiver back — chaining);
+ * setDefaultMaxChk is the static/property form, its second argument
+ * naming the message slot ("setMaxListeners" for the static call,
+ * "defaultMaxListeners" for the module-property assignment). */
+ | "emitter.setMaxChk" | "emitter.setDefaultMaxChk"
 /** The Buffer forms of the fs quartet: readFileSync(path) with NO
  * encoding → bytes<u8> (+1), writeFileSync(path, bytes), and the
  * fs/promises readFile(path) no-encoding form (an already-settled
@@ -2176,6 +2262,20 @@ export type IrLibFn = "island.eval"
  * field to stamp. error.toString: borrowed `%Error`-typed receiver, +1
  * string in Node's "name: message" shape. None of the three throws. */
  | "error.new"
+/** The compiler-resolved Node-parity throw for always-throwing lowered
+ * arms (ERR_INVALID_THIS receivers, ERR_MISSING_ARGS arity ladders,
+ * the symbol-to-string TypeError): args are [error-kind f64 (the
+ * SCR_ERR_* index: 0 Error, 1 TypeError, 2 RangeError), code (empty =
+ * no code slot), message]. ALWAYS THROWS catchably; the result type is
+ * the replaced expression's own (never materialized — the
+ * global.undefRead pattern). May-throw seed. */
+ | "error.nodeThrow"
+/** JS ToString over a DOM value WITH the object protocol (a user
+ * toString/valueOf member is CALLED and its throw propagates;
+ * exhaustion throws "Cannot convert object to primitive value"; units
+ * render "null"/"undefined") — the WHATWG USVString conversions
+ * (URLSearchParams names/values). Borrowed dyn; +1 string. May-throw. */
+ | "dyn.toStringCoerce"
 /** A read of a `declare`d const NOTHING defines (the bundler-define
  * pattern — __VERSION__): always throws the catchable ReferenceError
  * Node raises at the access ("<name> is not defined"). args[0] is the
@@ -2230,7 +2330,7 @@ export type IrLibFn = "island.eval"
  * JS). Strings/arrays/bytes answer their index keys; other scalars an
  * empty array; null/undefined throw Node's catchable TypeError
  * ("Cannot convert undefined or null to object"). */
- | "dyn.objKeys" | "dyn.objValues" | "dyn.objEntries"
+ | "dyn.objKeys" | "dyn.hasOwn" | "dyn.assign" | "dyn.objValues" | "dyn.objEntries"
 /** structuredClone over the DOM (scr_json.c): the JSON-safe subset plus
  * bytes (a fresh copy — a Buffer clones as a plain Uint8Array, like
  * Node), deep. Functions and handle kinds throw the spec's catchable
@@ -2334,7 +2434,13 @@ export type IrLibFn = "island.eval"
  * propagates the first error by destroying the rest, calls cb after the
  * last 'close'; answers the destination +1. The Dyn twins take the
  * callback as a checked-dynamic VALUE (mustCall wrappers). */
- | "stream.finished" | "stream.finishedDyn" | "stream.pipeline" | "stream.pipelineDyn" | "readable.newDyn" | "writable.newDyn" | "duplex.newDyn" | "transform.newDyn" | "passthrough.newDyn" | "readable.initDyn" | "writable.initDyn" | "duplex.initDyn" | "transform.initDyn" | "passthrough.initDyn" | "readable.push" | "readable.pushStr" | "readable.pushNull" | "readable.pushU" | "readable.pushDyn" | "readable.unshift" | "readable.unshiftStr" | "readable.read" | "readable.pause" | "readable.resume" | "readable.setEncoding"
+ | "stream.finished" | "stream.finishedDyn" | "stream.pipeline" | "stream.pipelineDyn"
+/** node:stream/promises — the promise forms over the same machinery:
+ * sp.finished: (s) → a pending void promise the terminal watcher
+ * settles; sp.pipeline: (count, s1..sn) → the callback pipeline's
+ * chaining/destroyer semantics settling a void promise (fulfilled on a
+ * clean finish, rejected with the finish status otherwise). */
+ | "sp.finished" | "sp.pipeline" | "readable.newDyn" | "writable.newDyn" | "duplex.newDyn" | "transform.newDyn" | "passthrough.newDyn" | "readable.initDyn" | "writable.initDyn" | "duplex.initDyn" | "transform.initDyn" | "passthrough.initDyn" | "readable.push" | "readable.pushStr" | "readable.pushNull" | "readable.pushU" | "readable.pushDyn" | "readable.unshift" | "readable.unshiftStr" | "readable.read" | "readable.pause" | "readable.resume" | "readable.setEncoding"
 /** for-await over a readable (the desugared loop's per-pass promise):
  * +1 promise of the next chunk — buffered content, the EOF sentinel
  * (empty Buffer / dyn undefined), or a rejection with the stream's
@@ -3558,12 +3664,26 @@ export type IrExpr = {
  * message exactly). A function callee calls through the boxed thunk:
  * per-arg validation against the boxed signature (mismatches throw the
  * path-annotated TypeError), result converted back to dyn. Callee and
- * args are borrowed; the result is owned (+1). MAY THROW. */
+ * args are borrowed; the result is owned (+1). MAY THROW.
+ *
+ * `spreads` (the runtime-arity form — `f(...args)`, the rest-forwarding
+ * idiom): entries name indices into `args` whose DOM values FLATTEN into
+ * the argument vector at the call — JS's spread over the DOM's iterable
+ * kinds (arrays element-by-element, strings by code point, bytes by
+ * byte; every other kind throws V8's exact spread-call TypeError,
+ * catchably — `what` is the spread expression's source spelling, which
+ * the nullish text spells), evaluated and flattened left-to-right (JS's
+ * ArgumentListEvaluation). The emitters build one fresh argument array
+ * and apply through it. */
  | {
     kind: "dynCall";
     callee: IrExpr;
     calleeName: string;
     args: IrExpr[];
+    spreads?: {
+        arg: number;
+        what: string;
+    }[];
     type: IrType;
     loc: SrcLoc;
 }
@@ -3932,11 +4052,15 @@ export type IrExpr = {
  * comparison (`u === "text"`) arrives here after the frontend wraps the
  * plain side (payload identity is preserved by the wrap, so ref-arm
  * semantics stay JS-exact). Operands are borrowed; result is a plain
- * bool. `negated` is the `!==` spelling. */
+ * bool. `negated` is the `!==` spelling. `sameValue` upgrades the f64
+ * arm's compare from `===` to SameValue (NaN equals NaN, +0 differs
+ * from -0) — the Object.is lowering; every other arm's compare is
+ * shared between the two semantics. */
  | {
     kind: "unionEq";
     unionId: string;
     negated: boolean;
+    sameValue: boolean;
     left: IrExpr;
     right: IrExpr;
     type: IrType;
@@ -4108,6 +4232,15 @@ export type IrJsOp = "add" | "sub" | "mul" | "div" | "mod" | "pow" | "neg" | "pl
  * engine, Symbol.hasInstance included; a non-object RHS throws the
  * engine's own TypeError, bridged catchably. */
  | "instanceOf" | "truthy" | "not" | "typeof" | "toStr" | "getProp" | "setProp" | "getIdx" | "setIdx" | "callMethod" | "callFn"
+/** Spread application on an island callee — `f(...pre, ...s)`, the
+ * rest-forwarding idiom (`(...args) => g(...args)` under --dynamic).
+ * Args are exactly (callee, pre, spread): `pre` is the engine array of
+ * leading fixed arguments (jsOp arrLit), `spread` the spread source;
+ * `name` carries the spread expression's source spelling (V8's nullish
+ * spread-call TypeError spells it). The prelude helper uses REAL spread
+ * syntax, so iterator protocols are the engine's own, with guards
+ * front-running V8's exact spread-call TypeError texts. May throw. */
+ | "callSpread"
 /** `new X(...)` where X is jsval-typed (package-declared classes):
  * JS_CallConstructor — args are the callee then the constructor
  * arguments, mirroring callFn. */
@@ -4122,6 +4255,23 @@ export type IrJsOp = "add" | "sub" | "mul" | "div" | "mod" | "pow" | "neg" | "pl
  * are alternating key/value jsvals (keys are marshaled strings), arrLit
  * args are the elements. Never throw. */
  | "objLit" | "arrLit"
+/** The engine-native TemplateStringsArray for an ISLAND TAG call: args
+ * are 2n marshaled strings — n cooked then n raw — building a fresh
+ * engine array whose `.raw` carries the raw spellings (tags dispatch on
+ * it). Never throws. */
+ | "tplStrings"
+/** Spread completion for an island-native object literal: copies
+ * args[1]'s own enumerable properties onto args[0] (the spec's
+ * CopyDataProperties — the engine's own Object.assign; null/undefined
+ * sources spread nothing) and answers args[0] for chaining. May throw
+ * (getters run). */
+ | "objSpread"
+/** Accessor completion for an island-native object literal: defines a
+ * GETTER property on args[0] (the object) — args are (obj, key string
+ * marshal, getter function handle) — and answers the same object (the
+ * chainable spelling: `defineGetter(objLit(...), k, f)`). The
+ * self-referential doc-printer root-indent shape. Never throws. */
+ | "defineGetter"
 /** The engine's own undefined / null as island values (zero args, never
  * throw): the unit arms of a union marshaling IN (`string | undefined`
  * into an 'any' slot — the undefined arm IS the engine undefined), and
@@ -4202,7 +4352,7 @@ export declare function isIslandCallbackParamType(t: IrType, getRecord: (shapeId
  * composites: still fenced). */
 export declare function islandCallbackRet(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): {
     async: boolean;
-    tag: "void" | "jsval" | "f64" | "bool" | "string" | "json";
+    tag: "void" | "jsval" | "f64" | "bool" | "string" | "json" | "dyn";
 } | null;
 /** The TYPED extension of canMarshalFuncIntoIsland (a strict superset):
  * closures whose params are per-argument-convertible at call time

package/dist/ir/nodes.js

@@ -143,6 +143,11 @@ export function isSupportedMapValue(t) {
         // references at all, so no trace, no cycles, ever.
         case "classval":
             return true;
+        // A regex (Map<string, RegExp> — the per-EOL pattern table): the
+        // array-element story (scr_regex retain/release adapters, no trace —
+        // a regex holds no references), map form.
+        case "regex":
+            return true;
         default:
             return false;
     }
@@ -150,10 +155,22 @@ export function isSupportedMapValue(t) {
 /** The INDEX-SIGNATURE value fence (`{ [k: string]: V }` shapes): the map
  * VALUE kinds — the overflow portion IS a string-keyed map — plus dyn
  * (`unknown`, an unknown-valued pricing-table shape: overflow reads surface ordinary
- * dyn values validated by the usual checked casts). Shared frontend
- * (mapType) / validator. */
+ * dyn values validated by the usual checked casts) and three kinds the
+ * overflow store carries that user Maps don't admit yet:
+ *   func — `Record<string, () => void>`, the command-registry pattern
+ *          (scr_closure adapters; closures are cycle-headered and traced,
+ *          so a handler capturing its own registry collects)
+ *   map/set — `Record<string, Map<K, V>>`/`Record<string, Set<T>>`
+ *          nested-container tables (scr_map adapters; a map value's own
+ *          cycle capability propagates through the trace fixpoint)
+ * Nested index-signature RECORDS ride the record kind like any other.
+ * Shared frontend (mapType) / validator. */
 export function isSupportedIndexValue(t) {
-    return t.kind === "dyn" || isSupportedMapValue(t);
+    return (t.kind === "dyn" ||
+        t.kind === "func" ||
+        t.kind === "map" ||
+        t.kind === "set" ||
+        isSupportedMapValue(t));
 }
 export function funcOf(params, ret) {
     return { kind: "func", params, ret };
@@ -219,7 +236,7 @@ export function typeKey(t) {
         case "set":
             return `set<${typeKey(t.elem)}>`;
         case "func":
-            return `func(${[...t.params.map(typeKey), ...(t.rest ? ["...dyn[]"] : [])].join(",")})=>${typeKey(t.ret)}`;
+            return `func(${[...t.params.map(typeKey), ...(t.rest ? [t.restAbi === "jsval" ? "...jsval[]" : "...dyn[]"] : [])].join(",")})=>${typeKey(t.ret)}`;
         case "object":
             return `object:${t.className}`;
         case "classval":
@@ -456,6 +473,14 @@ export const MAY_THROW_BYTES_METHODS = new Set([
     "dvGetFloat64",
     "dvGetBigUint64Number",
     "dvGetBigInt64Number",
+    "dvSetUint8",
+    "dvSetInt8",
+    "dvSetUint16",
+    "dvSetInt16",
+    "dvSetUint32",
+    "dvSetInt32",
+    "dvSetFloat32",
+    "dvSetFloat64",
 ]);
 /** Result-type rule for each island op (the validator enforces it; the
  * frontend constructs nodes with exactly these). */
@@ -473,10 +498,14 @@ export function jsOpResultKind(op) {
         case "getIdx":
         case "callMethod":
         case "callFn":
+        case "callSpread":
         case "construct":
         case "globalGet":
         case "objLit":
         case "arrLit":
+        case "defineGetter":
+        case "tplStrings":
+        case "objSpread":
         case "undefLit":
         case "nullLit":
         case "iterNew":
@@ -672,6 +701,7 @@ export function canCrossIslandBoundary(t, getRecord, getUnion) {
 export const MAX_ISLAND_CALLBACK_ARITY = 16;
 export function canMarshalFuncIntoIsland(t) {
     return (t.kind === "func" &&
+        t.rest !== true &&
         t.params.length <= MAX_ISLAND_CALLBACK_ARITY &&
         t.params.every((p) => p.kind === "jsval") &&
         (t.ret.kind === "jsval" || t.ret.kind === "void" ||
@@ -720,6 +750,13 @@ export function islandCallbackRet(t, getRecord, getUnion) {
     const tag = tagOf(t);
     if (tag)
         return { async: false, tag };
+    // A CHECKED-DYNAMIC result (a JS getter/callback whose inferred return
+    // degraded — the doc-printer root-indent getter): the DOM value deep-
+    // copies into the engine on return, exactly the jsMarshal dyn rule
+    // (data kinds only; boxed functions/handles throw the catchable
+    // TypeError). Sync only — no engine-promise tag exists for DOM values.
+    if (t.kind === "dyn")
+        return { async: false, tag: "dyn" };
     return isJsonSafeType(t, getRecord, getUnion) ? { async: false, tag: "json" } : null;
 }
 /** The TYPED extension of canMarshalFuncIntoIsland (a strict superset):
@@ -729,8 +766,22 @@ export function islandCallbackRet(t, getRecord, getUnion) {
  * buffer. Closures taking closures and 'unknown'-typed params stay fenced
  * (no per-type extraction exists for them inside a host call). */
 export function canMarshalTypedFuncIntoIsland(t, getRecord, getUnion) {
-    return (t.kind === "func" &&
-        t.params.length <= MAX_ISLAND_CALLBACK_ARITY &&
+    if (t.kind !== "func")
+        return false;
+    // The ISLAND-REST form (`async (...args) =>` in JS under --dynamic —
+    // the withPlugins wrapper): the trailing ABI param is the ENGINE array
+    // of the call's surplus arguments; leading params convert per argument
+    // like any typed callback. Plain rest signatures (dynRest, typed
+    // rests) stay out — no completed-ABI spelling exists for them here.
+    if (t.rest === true) {
+        return (t.restAbi === "jsval" &&
+            t.params.length >= 1 &&
+            t.params.length <= MAX_ISLAND_CALLBACK_ARITY &&
+            t.params[t.params.length - 1].kind === "jsval" &&
+            t.params.slice(0, -1).every((p) => isIslandCallbackParamType(p, getRecord, getUnion)) &&
+            islandCallbackRet(t.ret, getRecord, getUnion) !== null);
+    }
+    return (t.params.length <= MAX_ISLAND_CALLBACK_ARITY &&
         t.params.every((p) => isIslandCallbackParamType(p, getRecord, getUnion)) &&
         islandCallbackRet(t.ret, getRecord, getUnion) !== null);
 }
@@ -1119,6 +1170,7 @@ export function moduleUsesStream(mod) {
                 node.fn.startsWith("passthrough.") ||
                 node.fn === "stream.destroy" || node.fn === "stream.destroyErr" ||
                 node.fn === "stream.prop" || node.fn === "stream.errored" ||
+                node.fn === "sp.finished" || node.fn === "sp.pipeline" ||
                 node.fn.startsWith("stream.set"))) {
             found = true;
             return;
@@ -1977,6 +2029,8 @@ export const MAY_THROW_LIB_FNS = new Set([
     "stream.finishedDyn",
     "stream.pipeline",
     "stream.pipelineDyn",
+    "sp.finished",
+    "sp.pipeline",
     "readable.newDyn",
     "writable.newDyn",
     "duplex.newDyn",
@@ -2028,6 +2082,10 @@ export const MAY_THROW_LIB_FNS = new Set([
     // A read of a declare-d const nothing defines: always throws Node's
     // catchable ReferenceError.
     "global.undefRead",
+    // The compiler-resolved Node-parity throw: always throws, catchably.
+    "error.nodeThrow",
+    // USVString coercion runs user toString/valueOf — throws propagate.
+    "dyn.toStringCoerce",
     "child.kill",
     // The caller's lookup runs synchronously inside the connect call — a
     // throw there propagates like Node's.
@@ -2072,6 +2130,8 @@ export const MAY_THROW_LIB_FNS = new Set([
     "dyn.cloneTransferFail",
     // the dyn Object walks throw on null/undefined receivers
     "dyn.objKeys",
+    "dyn.hasOwn",
+    "dyn.assign",
     "dyn.objValues",
     "dyn.objEntries",
     "error.domClone",
@@ -2107,6 +2167,16 @@ export const MAY_THROW_LIB_FNS = new Set([
     "crypto.randomBytesToString",
     "crypto.randomBytes",
     "buffer.concatLen",
+    // The checked-dynamic compare/equals validators: Node's argument
+    // ladders throw ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE catchably.
+    "buffer.compareChk",
+    "bytes.equalsChk",
+    "bytes.compareChk",
+    "buffer.newStringFail",
+    "fs.toUnixTimestamp",
+    "error.argTypeThrow",
+    "emitter.setMaxChk",
+    "emitter.setDefaultMaxChk",
     "fs.readFileSyncBytes",
     "fs.writeFileSyncBytes",
     "zlib.inflateSync",