@scriptc/compiler 0.0.35 → 0.1.1

package/dist/ir/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../src/ir/build.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,GAAG,EAAyC,MAAM,EAAe,MAAM,SAAS,CAAC;AAEhG,MAAM,UAAU,MAAM,CAAC,OAAe,EAAE,IAAY,EAAE,GAAW;IAC/D,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AAChD,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAa,EAAE,GAAW;IAC/C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AACnD,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAa,EAAE,GAAW;IAC/C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;AACtD,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAc,EAAE,GAAW;IACjD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;AACrD,CAAC;AAED;;uEAEuE;AACvE,MAAM,UAAU,UAAU,CACxB,GAAW,EACX,KAAa,EACb,IAAiC;IAEjC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACtC,OAAO;QACL,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE;QACpE,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE;QAC1E,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE;YACnF,GAAG;SACJ;QACD,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC;QACjB,GAAG;KACJ,CAAC;AACJ,CAAC"}

package/dist/ir/integer-loops.d.ts

@@ -1,4 +1,4 @@
-import type { IrExpr, IrLocal, IrStmt } from "./nodes.js";
+import type { IrExpr, IrLocal, IrStmt } from "./ir.js";
 /** A canonical byte loop whose induction variable is mathematically an
  * unsigned integer for every body entry. Backends may keep this binding in
  * integer storage while the loop runs, converting to f64 at ordinary JS

package/dist/ir/{nodes.d.ts → ir.d.ts}

@@ -382,6 +382,26 @@ export type IrType = {
 } | {
     kind: "void";
 };
+interface IrKindSet<K extends IrType["kind"]> extends ReadonlySet<IrType["kind"]> {
+    has(kind: IrType["kind"]): kind is K;
+}
+/** The opaque runtime handle kinds. procStream is the one scalar handle;
+ * every other handle has pointer representation. */
+declare const HANDLE_KIND_LIST: readonly ["stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "fsWatcher", "childStream", "procStream"];
+export type HandleKind = typeof HANDLE_KIND_LIST[number];
+export declare const HANDLE_KINDS: IrKindSet<"fileHandle" | "stats" | "spawnRes" | "child" | "netServer" | "netSocket" | "http2Session" | "http2Stream" | "dgramSocket" | "testCtx" | "httpReq" | "httpRes" | "httpClientReq" | "childStream" | "procStream" | "fsWatcher" | "secureCtx">;
+/** The IR kinds represented as pointers in both native backends. */
+declare const POINTER_KIND_LIST: readonly ["string", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "fsWatcher", "childStream", "func", "object", "classval", "record", "union", "dyn", "jsval", "caught", "promise", "generator"];
+export type PointerKind = typeof POINTER_KIND_LIST[number];
+export declare const POINTER_KINDS: IrKindSet<"string" | "symbol" | "object" | "map" | "bytes" | "regex" | "fileHandle" | "searchParams" | "array" | "set" | "url" | "stats" | "spawnRes" | "child" | "netServer" | "netSocket" | "http2Session" | "http2Stream" | "dgramSocket" | "testCtx" | "httpReq" | "httpRes" | "httpClientReq" | "childStream" | "fsWatcher" | "secureCtx" | "func" | "jsval" | "classval" | "record" | "union" | "dyn" | "caught" | "promise" | "generator">;
+/** 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 declare const RUNTIME_RC_STEMS: Record<IrType["kind"], string>;
+/** 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 declare function runtimeRcStem(t: IrType): string | null;
 /** 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
@@ -499,7 +519,7 @@ export declare function typeEquals(a: IrType, b: IrType): boolean;
 export declare function isRefCounted(t: IrType): boolean;
 export interface IrModule {
     /** Bumped on any breaking IR change; serialize.ts refuses mismatches. */
-    irVersion: 6;
+    irVersion: 8;
     sourceFile: string;
     functions: IrFunction[];
     /** Class shapes. Constructors and methods are ordinary module functions
@@ -1069,9 +1089,9 @@ export type IrStmt =
     loc: SrcLoc;
 }
 /** Element write `a[i] = v` — statement-only, like `assign`. Valid indices
- * are [0, length]; i == length appends (JS would create a hole past that —
- * scriptc traps instead, see SEMANTICS.md). Ownership of a refcounted
- * value MOVES into the array; the replaced element is released. */
+ * are canonical array indices; writes beyond length grow the array and
+ * leave the intervening positions as holes. Ownership of a refcounted value
+ * MOVES into the array; the replaced element is released. */
  | {
     kind: "arraySet";
     arr: IrExpr;
@@ -1079,6 +1099,29 @@ export type IrStmt =
     value: IrExpr;
     loc: SrcLoc;
 }
+/** Writable `a.length = n`: growth creates holes and truncation releases
+ * removed reference elements. Invalid array lengths raise a catchable
+ * RangeError from the runtime. */
+ | {
+    kind: "arraySetLength";
+    arr: IrExpr;
+    length: IrExpr;
+    loc: SrcLoc;
+}
+/** Write an explicit present `undefined` state without shrinking length. */
+ | {
+    kind: "arraySetUndefined";
+    arr: IrExpr;
+    index: IrExpr;
+    loc: SrcLoc;
+}
+/** Delete an indexed/property slot without changing Array.length. */
+ | {
+    kind: "arrayDelete";
+    arr: IrExpr;
+    index: IrExpr;
+    loc: SrcLoc;
+}
 /** Typed-array element write `b[i] = v` — arraySet's sibling for bytes
  * receivers: statement-only, receiver and index like bytesIntrinsic
  * `get` (any invalid index TRAPS — JS would ignore the write, a
@@ -1266,12 +1309,19 @@ export type IrStmt =
  * from the end, clamping; omitted args omitted from `args` — backends fill
  * 0 / +Infinity, the strIntrinsic convention); ref elements retain into
  * the fresh array. */
-export type IrArrIntrinsicMethod = "length" | "push" | "pushSpread" | "unshift" | "unshiftSpread" | "pop" | "indexOf" | "includes" | "join" | "slice" | "shift" | "splice" | "reverse"
+export type IrArrIntrinsicMethod = "length" | "push" | "pushSpread" | "concatSpread" | "unshift" | "unshiftSpread" | "pop" | "indexOf" | "includes"
+/** Internal sparse traversal: the first present index at/after start,
+ * or length when the remaining positions are holes. */
+ | "nextPresent" | "join" | "slice" | "shift" | "splice" | "reverse"
 /** ES2023 copying methods. `toSpliced` receives [start, deleteCount,
  * itemsArray], with omitted arguments completed by the frontend;
  * `with` receives [index, value] and throws Node's catchable RangeError
  * when the relative index is out of range. */
- | "toReversed" | "toSpliced" | "with";
+ | "toReversed" | "toSpliced"
+/** `.with()` replacement carrying present undefined while retaining the
+ * scalar array payload ABI; it has the same catchable index validation as
+ * the typed replacement forms. */
+ | "withUndefined" | "with";
 /** Array intrinsics whose runtime implementation can raise a catchable
  * exception (rather than the static tier's deliberate index traps). */
 export declare const MAY_THROW_ARR_METHODS: ReadonlySet<IrArrIntrinsicMethod>;
@@ -1858,9 +1908,16 @@ export type IrLibFn =
  * (portless's listenOnProxyInterface): args [server, port, host,
  * ipv6Only]. host is an IP literal string ("" = the host-less
  * dual-stack any default); ipv6Only sets IPV6_V6ONLY before the bind.
- * Failures are the async 'error', message in Node's listen shape with
- * the requested host. Never throws. */
- | "net.listenOpts" | "net.listenOptsCb" | "net.serverPort"
+ * These are the old-shaped calls, retained for omitted reusePort so
+ * serialized IR remains compatible. Failures are the async 'error',
+ * message in Node's listen shape with the requested host. Never throws. */
+ | "net.listenOpts" | "net.listenOptsCb"
+/** Additive ABI for listen({ ..., reusePort }) — args
+ * [server, port, host, ipv6Only, reusePort], with the callback following
+ * those values in the callback form. The final BOOL is the requested
+ * kernel connection-distribution option; old spellings remain
+ * four/five-argument calls so serialized IR stays compatible. */
+ | "net.listenOptsReusePort" | "net.listenOptsReusePortCb" | "net.serverPort"
 /** server.address() as the full AddressInfo record (the dgram.address
  * materialization pattern: the emitter builds the record from the three
  * runtime reads; the frontend pinned the shape). Never throws — before
@@ -2348,7 +2405,7 @@ export type IrLibFn =
  * promise, rejecting on failure like the other fsp members). The sync
  * pair THROWS catchably on failure exactly like the utf8 forms. */
  | "fs.readFileSyncBytes" | "fs.writeFileSyncBytes" | "fsp.readFileBytes"
-/** node:zlib (scr_zlib.c — cc.ts compiles/links it ONLY when these
+/** node:zlib (scr_zlib.c — native-toolchain.ts compiles/links it ONLY when these
  * appear on the IR, the regex/libcurl gating precedent): deflateSync/
  * inflateSync over u8 bytes with Node's default options. deflate never
  * throws (OOM aborts); inflate of corrupt input THROWS Node's error
@@ -2933,7 +2990,7 @@ export type IrLibFn =
  | "tp.setTimeout" | "tp.setImmediate"
 /** node:diagnostics_channel (scr_dc.c, linked when any dc.* appears —
  * the zlib gating precedent): a process-global name→channel registry;
- * channel values are f64 handles (types.ts maps Channel to F64, the
+ * channel values are f64 handles (type-mapper.ts maps Channel to F64, the
  * readline.Interface pattern). Subscribers are dyn function values —
  * identity-compared by unsubscribe, called (message, name) by publish
  * over a SNAPSHOT of the list (a subscriber unsubscribing itself
@@ -2944,7 +3001,7 @@ export type IrLibFn =
  * ERR_INVALID_ARG_TYPE TypeError for non-function subscribers. */
  | "dc.channel" | "dc.subscribe" | "dc.unsubscribe" | "dc.hasSubscribers" | "dc.publish" | "dc.chanSubscribe" | "dc.chanUnsubscribe" | "dc.chanHasSubscribers" | "dc.chanName"
 /** TracingChannel (dc.tracingChannel): a registry entry of the five
- * event channels, an f64 handle like Channel (types.ts). tcSubscribe/
+ * event channels, an f64 handle like Channel (type-mapper.ts). tcSubscribe/
  * tcUnsubscribe walk a dyn handlers object's five event keys (truthy
  * non-function slots throw the per-channel ERR_INVALID_ARG_TYPE);
  * tcTraceSync/tcTraceCallback/tcTracePromise run Node's publish choreography in C over
@@ -3566,9 +3623,9 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
-/** Element read `a[i]`. Index is f64; a non-integer or out-of-bounds index
- * traps at runtime (JS returns undefined — documented divergence). For
- * refcounted elements the result is a fresh owned (+1) reference. */
+/** Element read `a[i]`. Index is f64; the low-level accessors require a
+ * proven present slot and trap on a hole. For refcounted elements the result
+ * is a fresh owned (+1) reference. */
  | {
     kind: "arrayGet";
     arr: IrExpr;
@@ -3576,6 +3633,25 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
+/** Presence query for an array index. Invalid/non-index keys and holes
+ * answer false without reading the slot; present undefined answers true.
+ * The ordinary-read lowering must use arrayState before selecting its
+ * undefined arm. */
+ | {
+    kind: "arrayHas";
+    arr: IrExpr;
+    index: IrExpr;
+    type: IrType;
+    loc: SrcLoc;
+}
+/** Array slot state as f64: HOLE=0, VALUE=1, UNDEFINED=2. */
+ | {
+    kind: "arrayState";
+    arr: IrExpr;
+    index: IrExpr;
+    type: IrType;
+    loc: SrcLoc;
+}
 /** Array method/property on an array receiver: `length` (f64), `push`
  * (VARIADIC like JS — zero or more elem-typed args; every argument
  * evaluates before any appends, then each appends in order; returns the
@@ -3586,8 +3662,8 @@ export type IrExpr =
  * exactly like JS; returns the new length), `unshift` (the matching
  * variadic front insertion; all arguments evaluate before mutation and
  * ref ownership moves in), `unshiftSpread` (one borrowed same-typed array,
- * with self-spread snapshot semantics), `pop` (returns elem — traps on an
- * empty array; ownership moves OUT to the caller), `indexOf` (one
+ * with self-spread snapshot semantics), `pop` (returns `elem | undefined`
+ * and leaves an empty array unchanged; ownership moves OUT to the caller), `indexOf` (one
  * elem-typed arg, BORROWED; strict equality — NaN never matches; → f64),
  * `includes` (one elem-typed arg, borrowed; SameValueZero — NaN DOES
  * match; → bool), `join` (one string arg, borrowed; f64/bool/string
@@ -4790,6 +4866,11 @@ export declare function isUndefinedArmedUnion(t: IrType, getUnion: (unionId: str
  * every reachable constituent is; a cyclic VALUE of such a type throws
  * Node's circular-structure TypeError at runtime instead. */
 export declare function isJsonSafeType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
+/** 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 declare function isJsonStringifySafeType(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
 /** THE island boundary predicate: true when a static type can cross into
  * the island (jsMarshal — primitives by value, composites as deep JSON
  * copies) and back out (jsExit — strict primitive extraction, composites
@@ -4898,7 +4979,7 @@ export declare function canExitIslandToType(t: IrType, getRecord: (shapeId: stri
 /** 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 declare function moduleUsesRegex(mod: IrModule): boolean;
@@ -4916,7 +4997,7 @@ export declare function moduleUsesLegacyTextDecoder(mod: IrModule): boolean;
 export declare function moduleUsesFileHandle(mod: IrModule): boolean;
 /** 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.
@@ -4924,12 +5005,12 @@ export declare function moduleUsesFileHandle(mod: IrModule): boolean;
 export declare function moduleUsesFetch(mod: IrModule): boolean;
 /** 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 declare function moduleUsesProcessEvents(mod: IrModule): boolean;
 /** 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
@@ -4951,12 +5032,12 @@ export declare function moduleUsesStream(mod: IrModule): boolean;
  * the first; the emitted main installs it before any island entry). */
 export declare function moduleEmbedsBuiltin(mod: IrModule, builtin: string): boolean;
 /** 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 declare 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). */
@@ -4964,17 +5045,17 @@ export declare function moduleEmbedsCompressedNpm(mod: IrModule): boolean;
 /** 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 declare function moduleUsesZlib(mod: IrModule): boolean;
 /** 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 declare function moduleUsesDc(mod: IrModule): boolean;
 /** 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
@@ -4983,31 +5064,31 @@ export declare function moduleUsesAssert(mod: IrModule): boolean;
 /** 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 declare function moduleUsesDynInvoke(mod: IrModule): boolean;
 /** 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 declare function moduleUsesDynAsync(mod: IrModule): boolean;
 export declare function moduleUsesInspect(mod: IrModule): boolean;
 /** 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 declare function moduleUsesNet(mod: IrModule): boolean;
 /** 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
@@ -5036,25 +5117,25 @@ export declare function moduleUsesQs(mod: IrModule): boolean;
 export declare function moduleUsesParseArgs(mod: IrModule): boolean;
 /** 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 declare function moduleUsesFsWatch(mod: IrModule): boolean;
 /** 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 declare function moduleUsesNodeTest(mod: IrModule): boolean;
 /** 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. */
 export declare function moduleUsesDgram(mod: IrModule): boolean;
 /** 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 declare function moduleUsesHttpServer(mod: IrModule): boolean;
 /** True when the module uses the REAL h2 surface (scr_http2.c): any core
@@ -5063,7 +5144,7 @@ export declare function moduleUsesHttpServer(mod: IrModule): boolean;
 export declare function moduleUsesHttp2(mod: IrModule): boolean;
 /** 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 declare function moduleUsesTls(mod: IrModule): boolean;
@@ -5071,7 +5152,7 @@ export declare function moduleUsesTls(mod: IrModule): boolean;
  * 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 declare function moduleUsesTlsCa(mod: IrModule): boolean;
@@ -5110,3 +5191,4 @@ export declare function moduleLibNondeterministicSurface(mod: IrModule): string
  * seed on `dynCheck` and `awaitExpr` nodes, which throw on validation
  * failure / promise rejection). */
 export declare const MAY_THROW_LIB_FNS: ReadonlySet<IrLibFn>;
+export {};