@scriptc/compiler 0.0.35 → 0.1.1

package/dist/ir/{nodes.js → ir.js}

@@ -1,18 +1,119 @@
-/* scriptc IR — the only interface between frontend and backends.
- *
- * Design rules (see docs/ir.md for node-by-node semantics):
- * - Plain JSON-safe discriminated unions: no classes, no parent pointers,
- *   no cycles. Cross-references are by string id.
- * - Every node carries `loc` (source span) and every expression carries its
- *   computed `type` — backends never re-derive types.
- * - Structured control flow (statement tree), not basic blocks: the only
- * current backend is C and there are no optimization passes yet. When a mid-end
- *   arrives, a structured→CFG lowering pass slots in after validation.
- * - The type union is deliberately written for extension (`dyn` shipped
- *   with JSON, `promise` with async). All switches over IrType/IrExpr/
- *   IrStmt must have exhaustive `never` default arms so adding a member
- *   turns into compile errors, not silent misbehavior.
- */
+import { InternalCompilerError } from "../errors.js";
+const POINTER_HANDLE_KINDS = [
+    "stats",
+    "fileHandle",
+    "spawnRes",
+    "child",
+    "netServer",
+    "netSocket",
+    "http2Session",
+    "http2Stream",
+    "dgramSocket",
+    "testCtx",
+    "httpReq",
+    "httpRes",
+    "httpClientReq",
+    "secureCtx",
+    "fsWatcher",
+    "childStream",
+];
+function irKindSet(kinds) {
+    return new Set(kinds);
+}
+/** The opaque runtime handle kinds. procStream is the one scalar handle;
+ * every other handle has pointer representation. */
+const HANDLE_KIND_LIST = [
+    ...POINTER_HANDLE_KINDS,
+    "procStream",
+];
+export const HANDLE_KINDS = irKindSet(HANDLE_KIND_LIST);
+/** The IR kinds represented as pointers in both native backends. */
+const POINTER_KIND_LIST = [
+    "string",
+    "array",
+    "map",
+    "set",
+    "regex",
+    "bytes",
+    "url",
+    "searchParams",
+    "symbol",
+    ...POINTER_HANDLE_KINDS,
+    "func",
+    "object",
+    "classval",
+    "record",
+    "union",
+    "dyn",
+    "jsval",
+    "caught",
+    "promise",
+    "generator",
+];
+export const POINTER_KINDS = irKindSet(POINTER_KIND_LIST);
+/** Runtime RC symbol stem for each IR type kind. An empty stem means the
+ * kind is scalar/unit or uses an emitted per-shape helper (object/record).
+ * Keeping this exhaustive makes a new runtime handle kind a compile error
+ * until its one retain/release family is named here. */
+export const RUNTIME_RC_STEMS = {
+    f64: "",
+    date: "",
+    string: "scr_str",
+    bool: "",
+    array: "scr_arr",
+    map: "scr_map",
+    set: "scr_map",
+    regex: "scr_regex",
+    bytes: "scr_bytes",
+    url: "scr_url",
+    searchParams: "scr_sp",
+    symbol: "scr_sym",
+    stats: "scr_stats",
+    fileHandle: "scr_file_handle",
+    spawnRes: "scr_spawn_res",
+    child: "scr_child",
+    netServer: "scr_net_server",
+    netSocket: "scr_net_sock",
+    http2Session: "scr_http2_session",
+    http2Stream: "scr_http2_stream",
+    dgramSocket: "scr_dgram",
+    testCtx: "scr_testctx",
+    httpReq: "scr_http_req",
+    httpRes: "scr_http_res",
+    httpClientReq: "scr_http_client",
+    childStream: "scr_child_stream",
+    procStream: "",
+    fsWatcher: "scr_watcher",
+    secureCtx: "scr_secure_ctx",
+    func: "scr_closure",
+    object: "",
+    classval: "scr_classobj",
+    record: "",
+    union: "scr_union",
+    dyn: "scr_dyn",
+    jsval: "scr_jsval",
+    caught: "scr_caught",
+    promise: "scr_promise",
+    generator: "scr_gen",
+    undefinedT: "",
+    nullT: "",
+    void: "",
+};
+/** The runtime-provided RC family for a type, or null when the backend must
+ * use an emitted class/record helper (or the type is not refcounted). */
+export function runtimeRcStem(t) {
+    if (t.kind === "object") {
+        if (RUNTIME_ERROR_CLASSES.has(t.className))
+            return "scr_error";
+        if (t.className === RUNTIME_EMITTER_CLASS)
+            return "scr_emitter";
+        if (RUNTIME_STREAM_CLASSES.has(t.className))
+            return "scr_stream";
+        return null;
+    }
+    const stem = RUNTIME_RC_STEMS[t.kind];
+    return stem === "" ? null : stem;
+}
 /** The ref kinds whose values are JS OBJECTS for truthiness: always true
  * ([] and {} included) — toBool accepts them (the operand still evaluates;
  * the test is constant), and per-union truthiness helpers answer their
@@ -224,6 +325,8 @@ export function unionFuncSetArmsOk(arms) {
  * canonical) shapeId/unionId, so keys stay finite and comparable. Lives in
  * the IR (not the frontend) because both ends need it. */
 export function typeKey(t) {
+    if (HANDLE_KINDS.has(t.kind))
+        return t.kind;
     switch (t.kind) {
         case "f64":
         case "date":
@@ -233,23 +336,6 @@ export function typeKey(t) {
         case "url":
         case "searchParams":
         case "symbol":
-        case "stats":
-        case "fileHandle":
-        case "spawnRes":
-        case "child":
-        case "netServer":
-        case "netSocket":
-        case "http2Session":
-        case "http2Stream":
-        case "dgramSocket":
-        case "testCtx":
-        case "httpReq":
-        case "httpRes":
-        case "httpClientReq":
-        case "secureCtx":
-        case "fsWatcher":
-        case "childStream":
-        case "procStream":
         case "dyn":
         case "jsval":
         case "caught":
@@ -284,7 +370,7 @@ export function typeKey(t) {
         default: {
             const _exhaustive = t;
             void _exhaustive;
-            throw new Error("unreachable");
+            throw new InternalCompilerError("unreachable");
         }
     }
 }
@@ -332,74 +418,7 @@ export function typeEquals(a, b) {
  * this — adding a refcounted kind must not grow new per-kind checks outside
  * the type-directed helpers. */
 export function isRefCounted(t) {
-    return (t.kind === "string" ||
-        t.kind === "array" ||
-        t.kind === "map" ||
-        t.kind === "set" ||
-        // Every regex value is an immortal interned literal today, so its
-        // retains/releases are no-ops — riding the uniform machinery anyway
-        // means dynamic construction can arrive without a redesign.
-        t.kind === "regex" ||
-        // URL, Stats, and spawnSync-result instances are ordinary refcounted
-        // heap values (immutable, no cycles — strings/scalars inside only).
-        t.kind === "url" ||
-        // URLSearchParams lists are ordinary refcounted heap values (strings
-        // plus at most the owning-URL edge — no cycles).
-        t.kind === "searchParams" ||
-        // Symbols are the same story: immutable identity values holding at
-        // most two strings.
-        t.kind === "symbol" ||
-        t.kind === "stats" ||
-        t.kind === "fileHandle" ||
-        t.kind === "spawnRes" ||
-        t.kind === "child" ||
-        // net handles are refcounted like child (listeners drop at settle,
-        // so lean allocation — see the IrType comment).
-        t.kind === "netServer" ||
-        t.kind === "netSocket" ||
-        // h2 sessions/streams are refcounted like the net pair (listeners
-        // drop at settlement; the session→stream↔session cycle breaks there).
-        t.kind === "http2Session" ||
-        t.kind === "http2Stream" ||
-        t.kind === "dgramSocket" ||
-        // TestContext handles are refcounted like dgramSocket (the runner
-        // tree owns children; no cycles through the handle).
-        t.kind === "testCtx" ||
-        t.kind === "httpReq" ||
-        t.kind === "httpRes" ||
-        t.kind === "httpClientReq" ||
-        // SecureContext handles are refcounted like url/stats (immutable, no
-        // cycles — parsed cert/key material inside only).
-        t.kind === "secureCtx" ||
-        // FSWatcher handles are refcounted like child (listeners drop at
-        // close, so lean allocation — see the IrType comment).
-        t.kind === "fsWatcher" ||
-        // Child-output streams are refcounted like child (listeners drop at
-        // EOF — see the IrType comment).
-        t.kind === "childStream" ||
-        // Typed arrays / Buffers are ordinary refcounted heap values (mutable,
-        // no cycles — raw bytes inside only).
-        t.kind === "bytes" ||
-        t.kind === "func" ||
-        t.kind === "object" ||
-        // Every class object is an immortal emitted static, so its
-        // retains/releases are no-ops — riding the uniform machinery (the
-        // regex-literal stance) keeps every container and box path unchanged.
-        t.kind === "classval" ||
-        t.kind === "record" ||
-        // The union CONTAINER is heap/refcounted regardless of which arm it
-        // holds (uniform representation keeps the RC discipline simple).
-        t.kind === "union" ||
-        t.kind === "promise" ||
-        // A generator object is a refcounted handle over its paused fiber and
-        // typed channel slots (ScrGen — lean allocation, no cycle header).
-        t.kind === "generator" ||
-        // A dyn value is a refcounted JSON dyn tree (ScrDyn).
-        t.kind === "dyn" ||
-        // An island value is a refcounted cell owning one engine value.
-        t.kind === "jsval" ||
-        // A catch binding is a refcounted snapshot box (ScrCaught).
-        t.kind === "caught");
+    return RUNTIME_RC_STEMS[t.kind] !== "" || t.kind === "object" || t.kind === "record";
 }
 export function isFfiCallbackParam(param) {
     return typeof param === "object" && "callback" in param && "id" in param.callback;
@@ -529,6 +548,7 @@ export function shapeHasAccessorSlots(shape) {
  * exception (rather than the static tier's deliberate index traps). */
 export const MAY_THROW_ARR_METHODS = new Set([
     "with",
+    "withUndefined",
 ]);
 /** The bytesIntrinsic methods that can raise a catchable error — backends'
  * may-throw analyses seed on these exactly like MAY_THROW_LIB_FNS. */
@@ -618,7 +638,7 @@ export function jsOpResultKind(op) {
         default: {
             const _exhaustive = op;
             void _exhaustive;
-            throw new Error("unreachable");
+            throw new InternalCompilerError("unreachable");
         }
     }
 }
@@ -648,24 +668,28 @@ export function isUndefinedArmedUnion(t, getUnion) {
  * every reachable constituent is; a cyclic VALUE of such a type throws
  * Node's circular-structure TypeError at runtime instead. */
 export function isJsonSafeType(t, getRecord, getUnion) {
-    return isJsonSafeAt(t, getRecord, getUnion, false, new Set());
-}
-/** The recursion behind isJsonSafeType. `inRecordField` is the ONE position
- * where an undefined arm is JSON-representable: an undefined-armed union as
- * a record field (the `a?: T` spelling) serializes by DROPPING the field
- * when it holds undefined and validates a MISSING key as the undefined arm
- * — both exactly Node. Everywhere else (a bare `T | undefined` value,
- * stringified whole or cast to) exactness is unreachable: Node's stringify
- * of bare undefined is not a string at all, and JSON text can never contain
- * a value that matches the arm. */
-function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
+    return isJsonSafeAt(t, getRecord, getUnion, false, false, new Set());
+}
+/** The JSON.stringify-only domain additionally admits undefined arms in
+ * array and tuple positions, where Node emits null. A bare undefined-armed
+ * root remains outside the domain because JSON.stringify returns the
+ * undefined value instead of a string. */
+export function isJsonStringifySafeType(t, getRecord, getUnion) {
+    return isJsonSafeAt(t, getRecord, getUnion, true, false, new Set());
+}
+/** The recursion shared by checked JSON conversion and stringification.
+ * Ordinary record fields always admit undefined by dropping the key. Array
+ * and tuple slots admit it only for stringification, which writes null. */
+function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visiting) {
+    if (HANDLE_KINDS.has(t.kind))
+        return false;
     switch (t.kind) {
         case "f64":
         case "string":
         case "bool":
             return true;
         case "array":
-            return isJsonSafeAt(t.elem, getRecord, getUnion, false, visiting);
+            return isJsonSafeAt(t.elem, getRecord, getUnion, stringify, stringify, visiting);
         case "record": {
             const shape = getRecord(t.shapeId);
             if (!shape)
@@ -676,10 +700,7 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
             if (visiting.has(t.shapeId))
                 return true;
             visiting.add(t.shapeId);
-            // TUPLE positions are array slots, not droppable object keys: an
-            // undefined-armed position would stringify as `null` in JS (not
-            // drop), so tuples keep the array rule for their fields.
-            if (!shape.fields.every((f) => isJsonSafeAt(f.type, getRecord, getUnion, !shape.tuple, visiting))) {
+            if (!shape.fields.every((f) => isJsonSafeAt(f.type, getRecord, getUnion, stringify, !shape.tuple || stringify, visiting))) {
                 return false;
             }
             // Overflow values sit in record-key position too: dyn is JSON-safe
@@ -687,7 +708,7 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
             // like any undefined-valued key), everything else follows the
             // record-field rule.
             if (shape.indexValue && shape.indexValue.kind !== "dyn") {
-                return isJsonSafeAt(shape.indexValue, getRecord, getUnion, true, visiting);
+                return isJsonSafeAt(shape.indexValue, getRecord, getUnion, stringify, true, visiting);
             }
             return true;
         }
@@ -695,11 +716,11 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
             const def = getUnion(t.unionId);
             if (!def)
                 return false;
-            const key = `${t.unionId}:${inRecordField}`;
+            const key = `${t.unionId}:${stringify}:${undefinedAllowed}`;
             if (visiting.has(key))
                 return true; // the recursive knot, union-flavored
             visiting.add(key);
-            return def.arms.every((a) => isJsonSafeAt(a, getRecord, getUnion, inRecordField, visiting));
+            return def.arms.every((a) => a.kind === "undefinedT" ? undefinedAllowed : isJsonSafeAt(a, getRecord, getUnion, stringify, undefinedAllowed, visiting));
         }
         case "func":
         case "object":
@@ -728,23 +749,6 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
         // Buffers as {type:"Buffer",data:[...]} in Node — neither shape is
         // representable type-directedly; rejected like Maps.
         case "bytes":
-        case "stats":
-        case "fileHandle":
-        case "spawnRes":
-        case "child":
-        case "netServer":
-        case "netSocket":
-        case "http2Session":
-        case "http2Stream":
-        case "dgramSocket":
-        case "testCtx":
-        case "httpReq":
-        case "httpRes":
-        case "httpClientReq":
-        case "secureCtx":
-        case "fsWatcher":
-        case "childStream":
-        case "procStream":
         case "dyn":
         case "jsval":
         case "caught":
@@ -752,12 +756,10 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
         case "generator":
         case "void":
             return false;
-        // Representable exactly as a union arm in record-field position (the
-        // optional-field story above); bare undefined-armed unions stay fenced
-        // out of both stringify and dynCheck (narrow with '!== undefined'
-        // first, or model absence with a null arm).
+        // Record fields drop undefined. Stringification also represents it in
+        // array and tuple slots as null; bare roots remain fenced.
         case "undefinedT":
-            return inRecordField;
+            return undefinedAllowed;
         // JSON null ↔ the nullT arm: null-armed unions stringify (`null`) and
         // validate (a JSON null matches exactly the nullT arm).
         case "nullT":
@@ -765,7 +767,7 @@ function isJsonSafeAt(t, getRecord, getUnion, inRecordField, visiting) {
         default: {
             const _exhaustive = t;
             void _exhaustive;
-            throw new Error("unreachable");
+            throw new InternalCompilerError("unreachable");
         }
     }
 }
@@ -1126,7 +1128,7 @@ export function canExitIslandToType(t, getRecord, getUnion) {
 /** True when the module contains any regex construct — a regexLit /
  * regexIntrinsic node or a regex-typed slot anywhere. This is the link
  * switch that pulls scr_regex.c + the vendored libregexp into the binary
- * (cc.ts); regex-free programs keep the historical command line. A generic
+ * (native-toolchain.ts); regex-free programs keep the historical command line. A generic
  * JSON walk: `kind` discriminants live only on IR objects, so user string
  * VALUES can never false-positive. */
 export function moduleUsesRegex(mod) {
@@ -1182,7 +1184,8 @@ export function moduleUsesCopying(mod) {
         if (node.kind === "arrIntrinsic" &&
             (node.method === "toReversed" ||
                 node.method === "toSpliced" ||
-                node.method === "with")) {
+                node.method === "with" ||
+                node.method === "withUndefined")) {
             found = true;
             return;
         }
@@ -1249,7 +1252,7 @@ export function moduleUsesFileHandle(mod) {
 }
 /** True when user code lowers static fetch or the embedded npm graph
  * reaches the engine's global fetch — the link switch that pulls scr_fetch.c +
- * its socket/tls/zlib dependencies into the binary (cc.ts) and has the
+ * its socket/tls/zlib dependencies into the binary (native-toolchain.ts) and has the
  * emitted main call scr_fetch_install. The npm graph records the embedded
  * source fact with a parser + binder, so comments, strings, property names,
  * and local `fetch` bindings do not change the link or target capability.
@@ -1301,7 +1304,7 @@ const PROCESS_EVENT_LIB_FNS = new Set([
 ]);
 /** True when the module uses the process-events surface — the link switch
  * that pulls scr_events.c into the binary and has the emitted main call
- * scr_events_install (cc.ts + emitter; the scr_regex/scr_fetch/scr_zlib
+ * scr_events_install (native-toolchain.ts + emitter; the scr_regex/scr_fetch/scr_zlib
  * gating precedent). Event-free programs pay zero bytes and keep their
  * exact link line. Same generic-walk shape as moduleUsesRegex. */
 export function moduleUsesProcessEvents(mod) {
@@ -1326,7 +1329,7 @@ export function moduleUsesProcessEvents(mod) {
     return found;
 }
 /** True when the module uses the node:events EventEmitter surface — the
- * link switch that pulls scr_events_emitter.c into the binary (cc.ts; the
+ * link switch that pulls scr_events_emitter.c into the binary (native-toolchain.ts; the
  * scr_events.c gating precedent, but pure data structure: no install, no
  * loop hooks). Two signals: the `%EventEmitter` class def rides the
  * module (any emitter-typed value or `extends EventEmitter` subclass
@@ -1403,12 +1406,12 @@ export function moduleEmbedsBuiltin(mod, builtin) {
     return mod.embedded !== undefined && mod.embedded.edges.some((e) => e.to === builtin);
 }
 /** Embedded module texts at least this long are DEFLATE-compressed into
- * the emitted C (emit-island.ts; each stays plain when deflate does not
+ * the emitted C (island.ts; each stays plain when deflate does not
  * shrink it) and inflated lazily by the island's module loader at first
  * load. Below it the zlib round trip cannot pay for itself. */
 export const NPM_COMPRESS_MIN = 1024;
 /** True when the emitted npm tables will carry compressed module text —
- * the SAME candidate test emit-island.ts compresses by, so index.ts's
+ * the SAME candidate test island.ts compresses by, so index.ts's
  * zlib link switch and emitter.ts's inflater installation stay in
  * lockstep with the emission (a candidate whose deflate happens not to
  * shrink stays plain; the installed inflater is then just unused). */
@@ -1419,7 +1422,7 @@ export function moduleEmbedsCompressedNpm(mod) {
 /** True when the module contains any zlib libCall (the static lowering)
  * OR the embedded npm graph imports node:zlib (the island shim) — the
  * link switch that pulls scr_zlib.c + the system libz into the binary
- * (cc.ts); zlib-free programs keep their exact link line. Same
+ * (native-toolchain.ts); zlib-free programs keep their exact link line. Same
  * generic-walk shape as moduleUsesRegex: `kind`/`fn` discriminants live
  * only on IR objects. */
 export function moduleUsesZlib(mod) {
@@ -1447,7 +1450,7 @@ export function moduleUsesZlib(mod) {
 }
 /** True when the module contains any dc.* libCall — the link switch that
  * pulls scr_dc.c (the diagnostics_channel registry and pub/sub) into the
- * binary (cc.ts). Channel-free binaries keep their exact size class.
+ * binary (native-toolchain.ts). Channel-free binaries keep their exact size class.
  * Same walk shape as moduleUsesZlib. */
 export function moduleUsesDc(mod) {
     let found = false;
@@ -1471,7 +1474,7 @@ export function moduleUsesDc(mod) {
     return found;
 }
 /** True when the module contains any assert libCall — the link switch
- * that pulls scr_assert.c into the binary (cc.ts). scr_regex.c calls the
+ * that pulls scr_assert.c into the binary (native-toolchain.ts). scr_regex.c calls the
  * assert throw/inspect helpers (assert.match lives there), so the regex
  * switch also pulls scr_assert.c; assert-free, regex-free binaries keep
  * the historical command line and size. Same walk shape as
@@ -1500,7 +1503,7 @@ export function moduleUsesAssert(mod) {
 /** True when the module contains any dynInvoke node or dyn.defineProps
  * libCall — the link switch that pulls scr_dyn_invoke.c (the prototype-
  * method dispatch on dyn receivers, plus scr_dyn_display and
- * scr_dyn_define_props) into the binary (cc.ts; the assert gating
+ * scr_dyn_define_props) into the binary (native-toolchain.ts; the assert gating
  * precedent — dispatch-free binaries keep their exact size class). Same
  * walk shape as moduleUsesZlib. */
 export function moduleUsesDynInvoke(mod) {
@@ -1525,14 +1528,14 @@ export function moduleUsesDynInvoke(mod) {
     return found;
 }
 /** True when the module contains any insp libCall — the link switch that
- * pulls scr_inspect.c into the binary (cc.ts; the assert gating
+ * pulls scr_inspect.c into the binary (native-toolchain.ts; the assert gating
  * precedent — inspect-free binaries keep the historical command line and
  * size class). Same walk shape as moduleUsesZlib. */
 /** True when the module needs scr_async_dyn.c — the checked-dynamic
  * async surfaces (dyn-promise then/catch/finally reactions, await of a
  * dyn value, `new Promise(setImmediate)`, AsyncLocalStorage, the
  * unhandledRejection/warning process events). Also pulled by the
- * dynInvoke and dc gates (their TUs call into this one) — cc.ts. Same
+ * dynInvoke and dc gates (their TUs call into this one) — native-toolchain.ts. Same
  * walk shape as moduleUsesZlib. */
 export function moduleUsesDynAsync(mod) {
     const fns = new Set([
@@ -1593,7 +1596,7 @@ export function moduleUsesInspect(mod) {
 }
 /** True when the module contains any net libCall — the link switch that
  * pulls scr_net.c into the binary and has the emitted main call
- * scr_net_install (cc.ts + emitter; the scr_events gating precedent).
+ * scr_net_install (native-toolchain.ts + emitter; the scr_events gating precedent).
  * Net-free programs pay zero bytes and keep their exact link line. Same
  * generic-walk shape as moduleUsesZlib. */
 export function moduleUsesNet(mod) {
@@ -1636,7 +1639,7 @@ export function moduleUsesNet(mod) {
 }
 /** True when the module contains any sym.* libCall or a symbol-kind type
  * anywhere in the IR — the link switch that pulls scr_symbol.c into the
- * binary (cc.ts; the scr_net gating precedent — no install call, the
+ * binary (native-toolchain.ts; the scr_net gating precedent — no install call, the
  * Symbol.for registry initializes lazily). The TYPE check matters like
  * net's: a symbol-typed local whose initializer compiled to a runtime
  * fence still emits release calls that need the unit linked. Symbol-free
@@ -1755,7 +1758,7 @@ export function moduleUsesParseArgs(mod) {
 }
 /** True when the module contains any fs.watch/watcher.* libCall — the
  * link switch that pulls scr_watch.c into the binary and has the emitted
- * main call scr_watch_install (cc.ts + emitter; the scr_net gating
+ * main call scr_watch_install (native-toolchain.ts + emitter; the scr_net gating
  * precedent). Watch-free programs pay zero bytes and keep their exact
  * link line. Same generic-walk shape as moduleUsesZlib. */
 export function moduleUsesFsWatch(mod) {
@@ -1789,7 +1792,7 @@ export function moduleUsesFsWatch(mod) {
 /** True when the module contains any test.* libCall or a testCtx handle
  * type — the link switch that pulls scr_test.c into the binary and has
  * the emitted main return scr_test_exit_code() after the loop drains
- * (cc.ts + emitter; the moduleUsesDgram shape). Test-free programs pay
+ * (native-toolchain.ts + emitter; the moduleUsesDgram shape). Test-free programs pay
  * zero bytes and keep their exact link line. */
 export function moduleUsesNodeTest(mod) {
     let found = false;
@@ -1820,7 +1823,7 @@ export function moduleUsesNodeTest(mod) {
 }
 /** True when the module contains any dgram.* or dns.* libCall — the
  * link switch that pulls scr_dgram.c into the binary and has the emitted
- * main call scr_dgram_install (cc.ts + emitter; the scr_net gating
+ * main call scr_dgram_install (native-toolchain.ts + emitter; the scr_net gating
  * precedent — dns.lookup lives in the same unit, so either prefix
  * answers). Dgram-free programs pay zero bytes and keep their exact link
  * line. Same generic-walk shape as moduleUsesZlib. */
@@ -1853,7 +1856,7 @@ export function moduleUsesDgram(mod) {
     return found;
 }
 /** True when the module contains any http.* libCall — the link switch
- * that pulls scr_http.c into the binary (cc.ts; moduleUsesNet already
+ * that pulls scr_http.c into the binary (native-toolchain.ts; moduleUsesNet already
  * answers true for these, so scr_net.c comes along). */
 export function moduleUsesHttpServer(mod) {
     let found = false;
@@ -1926,7 +1929,7 @@ export function moduleUsesHttp2(mod) {
 }
 /** True when the module contains any tls.* or https.* libCall — the link
  * switch that pulls scr_tls.c and the vendored mbedTLS archive into the
- * binary (cc.ts; moduleUsesNet and moduleUsesHttpServer already answer
+ * binary (native-toolchain.ts; moduleUsesNet and moduleUsesHttpServer already answer
  * true for these, so scr_net.c and scr_http.c come along). TLS-free
  * programs keep their exact link line and never build mbedTLS. */
 export function moduleUsesTls(mod) {
@@ -1962,7 +1965,7 @@ export function moduleUsesTls(mod) {
  * for scr_tls_ca.c, the CA-store introspection unit (getCACertificates /
  * rootCertificates / setDefaultCACertificates). Deliberately SEPARATE
  * from moduleUsesTls: the unit is plain PEM-block bookkeeping, so a
- * program that only inspects the CA store never pulls mbedTLS. cc.ts
+ * program that only inspects the CA store never pulls mbedTLS. native-toolchain.ts
  * also compiles the unit whenever TLS itself links — scr_tls.c consults
  * the unit's default-set override for its trust anchors. */
 export function moduleUsesTlsCa(mod) {
@@ -2501,6 +2504,7 @@ export const MAY_THROW_LIB_FNS = new Set([
     "fs.statSync",
     "crypto.randomBytesToString",
     "crypto.randomBytes",
+    "buffer.concat",
     "buffer.concatLen",
     // The checked-dynamic compare/equals validators: Node's argument
     // ladders throw ERR_INVALID_ARG_TYPE / ERR_OUT_OF_RANGE catchably.
@@ -2603,4 +2607,4 @@ export const MAY_THROW_LIB_FNS = new Set([
     "crypto.x509ValidTo",
     "crypto.x509ValidToStr",
 ]);
-//# sourceMappingURL=nodes.js.map
+//# sourceMappingURL=ir.js.map