@scriptc/compiler 0.1.1 → 0.1.3

package/dist/ir/ir.d.ts

@@ -12,6 +12,14 @@ export type IrBytesElem = "u8" | "u32" | "i32" | "f32";
 export type IrType = {
     kind: "f64";
 }
+/** An ECMAScript bigint primitive. Runtime values are immutable,
+ * arbitrary-precision signed integers (ScrBigInt) whose numeric value,
+ * not pointer identity, defines equality. The heap representation is an
+ * implementation detail: bigint remains a JS primitive for truthiness,
+ * typeof, comparison, inspection, and container semantics. */
+ | {
+    kind: "bigint";
+}
 /** The supported ES Date value slice: a scalar TimeClip'd millisecond
  * value. Getters and toISOString observe only this slot, so copying it
  * through locals/params/fields is exact while Date mutation and object
@@ -216,6 +224,13 @@ export type IrType = {
  | {
     kind: "childStream";
 }
+/** A piped child-input stream (child.stdin — spawn with a piped stdin
+ * slot; scr_child.c). Heap, refcounted, and mutable: writes queue into
+ * the platform pipe without blocking the JavaScript thread, and
+ * drain/finish/error listeners drop when the writer settles. */
+ | {
+    kind: "childWriter";
+}
 /** A process output stream as a FIRST-CLASS value (process.stdout /
  * process.stderr flowing into a `NodeJS.WritableStream` slot — the
  * prefixStream idiom). Representation is the raw FD as a double (1 or
@@ -245,6 +260,16 @@ export type IrType = {
  | {
     kind: "secureCtx";
 }
+/** A node:crypto Hash or Hmac handle (scr_lib.c): heap, refcounted,
+ * MUTABLE until digest(), then permanently finalized. The two TypeScript
+ * surfaces share one runtime representation but stay distinct IR kinds so
+ * Hash.copy() cannot accidentally appear on Hmac values. The incremental
+ * digest state owns no script values and cannot participate in a cycle. */
+ | {
+    kind: "cryptoHash";
+} | {
+    kind: "cryptoHmac";
+}
 /** Heap, refcounted closure. `rest` marks a VARIADIC JS function (a
  * `...args` rest parameter, or a zero-param function body reading
  * `arguments` — test/common's mustCall wrapper): the lifted function
@@ -359,6 +384,7 @@ export type IrType = {
  * array elements, and JSON. */
  | {
     kind: "generator";
+    async?: true;
     yieldT: IrType;
     retT: IrType;
     nextT: IrType;
@@ -387,13 +413,13 @@ interface IrKindSet<K extends IrType["kind"]> extends ReadonlySet<IrType["kind"]
 }
 /** 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"];
+declare const HANDLE_KIND_LIST: readonly ["stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "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">;
+export declare const HANDLE_KINDS: IrKindSet<"child" | "childStream" | "childWriter" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
 /** 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"];
+declare const POINTER_KIND_LIST: readonly ["string", "bigint", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "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">;
+export declare const POINTER_KINDS: IrKindSet<"array" | "bigint" | "bytes" | "caught" | "child" | "childStream" | "childWriter" | "classval" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "jsval" | "map" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
 /** 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
@@ -408,6 +434,7 @@ export declare function runtimeRcStem(t: IrType): string | null;
  * arms with `true`. */
 export declare const REF_TRUTHY_KINDS: ReadonlySet<string>;
 export declare const F64: IrType;
+export declare const BIGINT_T: IrType;
 export declare const DATE_T: IrType;
 export declare const BYTES_U8: IrType;
 export declare const STRING: IrType;
@@ -430,8 +457,11 @@ export declare const HTTPREQ_T: IrType;
 export declare const HTTPRES_T: IrType;
 export declare const HTTPCLIENTREQ_T: IrType;
 export declare const SECURECTX_T: IrType;
+export declare const CRYPTOHASH_T: IrType;
+export declare const CRYPTOHMAC_T: IrType;
 export declare const FSWATCHER_T: IrType;
 export declare const CHILDSTREAM_T: IrType;
+export declare const CHILDWRITER_T: IrType;
 export declare const PROCSTREAM_T: IrType;
 export declare const VOID: IrType;
 export declare const DYN: IrType;
@@ -519,7 +549,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: 8;
+    irVersion: 9;
     sourceFile: string;
     functions: IrFunction[];
     /** Class shapes. Constructors and methods are ordinary module functions
@@ -945,7 +975,9 @@ export interface IrFunction {
      * Each is also listed in `locals` (with boxed: true); it is NOT a param. */
     captures?: IrParam[];
     /** Async: the body runs on a fiber; `returnType` is the INNER type T (a
-     * `return v` fulfills with v) while call sites receive Promise<T>. */
+     * `return v` fulfills with v) while ordinary call sites receive
+     * Promise<T>. With `generator` present, call sites receive the lazy
+     * async-generator object instead. */
     async?: true;
     /** Async module initializers only: a module-global Promise<T> slot where
      * the spawn wrapper caches its first evaluation promise. Every later
@@ -958,17 +990,21 @@ export interface IrFunction {
      * becomes the runtime cycle root. Dynamic imports wait on this shared
      * completion verdict instead of a build-time-selected member. */
     asyncCycleCacheGlobal?: string;
-    /** Generator (`function*`): the body runs on a fiber created SUSPENDED
+    /** Generator (`function*` / `async function*`): the body runs on a fiber created SUSPENDED
      * (nothing runs until the first `.next()`); `returnType` is the
      * generator's TReturn (VOID when it carries no value — `return;`
      * completes with the undefined arm) while call sites receive the
-     * generator type `{ yieldT, retT: returnType, nextT }` from an emitted
+     * generator type `{ async?, yieldT, retT: returnType, nextT }` from an emitted
      * spawn wrapper that only allocates. `yieldT` is what `yield e` sends
      * out, `nextT` what `.next(v)` sends in (the yield expression's result
-     * type). Mutually exclusive with `async` (async generators are fenced). */
+     * type). `async` alongside this field marks an async generator: its
+     * resume methods queue requests and return promises. */
     generator?: {
         yieldT: IrType;
         nextT: IrType;
+        resultType: IrType & {
+            kind: "record";
+        };
     };
     body: IrStmt[];
     loc: SrcLoc;
@@ -1283,23 +1319,19 @@ export type IrStmt =
  * completion AND on the exception path (after catch, or with the
  * exception still pending when there is no catch — it keeps propagating
  * after the finally completes; a throw inside the finally replaces it).
- * A `return` inside tryBody/catchBody additionally runs the finally on
- * its way out (the backend's PENDING-RETURN path: the value is computed
- * and snapshotted FIRST, every crossed finally runs inner-to-outer, then
- * the function returns — finally mutations of returned locals are
- * invisible, Node-exact; a throw inside such a finally replaces the
- * pending return, releasing the snapshot). The frontend still rejects
- * break/continue crossing a try-with-finally and ANY jump out of a
- * finally body, so normal, exception, and pending-return are the only
- * completions a finally sees; plain try/catch has no such restriction
- * (jumps out release the try scopes like any other jump). Each body is
- * its own lexical scope. */
+ * Every abrupt completion crossing the region runs the finally
+ * inner-to-outer. Return values are snapshotted first; break/continue
+ * retain their resolved targets; and a completion raised inside the
+ * finally replaces the pending one. Each body is its own lexical scope. */
  | {
     kind: "tryCatch";
     tryBody: IrStmt[];
     catchBody: IrStmt[] | null;
     catchLocalId: string | null;
     finallyBody: IrStmt[] | null;
+    /** Resource-management cleanup: if the guarded body and cleanup both
+     * throw, raise a SuppressedError instead of replacing the first error. */
+    suppressFinallyErrors?: true;
     loc: SrcLoc;
 };
 /** The complete array method/property surface (mirrors ambient/scriptc.d.ts).
@@ -1578,7 +1610,11 @@ export type IrLibFn =
  * (bytes decode per the literal encoding — utf8 default; strings,
  * numbers, booleans, arrays, objects answer JS-exactly; undefined and
  * null throw the catchable TypeError). */
- | "dyn.toString" | "fs.readFileSync"
+ | "dyn.toString"
+/** Engine-free CommonJS module graph. Module values are scalar f64
+ * handles; generated startup defines the registry, init wrappers update
+ * loading/cache state, and the read surface answers Node's live metadata. */
+ | "module.registryInit" | "module.define" | "module.enter" | "module.link" | "module.finish" | "module.fail" | "module.filename" | "module.id" | "module.path" | "module.paths" | "module.children" | "module.parent" | "module.loaded" | "module.cacheGet" | "module.cacheHas" | "module.cacheKeys" | "fs.readFileSync"
 /** readFileSync(path) — the Buffer read (+1 bytes); throws catchably
  * like the utf8 form. */
  | "fs.readFileSyncBuf"
@@ -1808,6 +1844,11 @@ export type IrLibFn =
  * (the runtime returns +1-or-NULL; the backend builds the union arms —
  * the child.stdout pattern). None of these throw. */
  | "sym.new" | "sym.newAnon" | "sym.for" | "sym.keyFor" | "sym.desc" | "sym.toString"
+/** Engine-free arbitrary-precision bigint operations (scr_bigint.c).
+ * parse accepts the ECMAScript BigInt string grammar; fromF64 accepts
+ * finite integral Numbers. Arithmetic returns fresh immutable values.
+ * cmp returns -1/0/1 as f64; toString accepts a numeric radix. */
+ | "bigint.parse" | "bigint.fromF64" | "bigint.neg" | "bigint.not" | "bigint.add" | "bigint.sub" | "bigint.mul" | "bigint.div" | "bigint.mod" | "bigint.pow" | "bigint.and" | "bigint.or" | "bigint.xor" | "bigint.shl" | "bigint.shr" | "bigint.eq" | "bigint.cmp" | "bigint.cmpNumber" | "bigint.truthy" | "bigint.toString" | "bigint.inspect" | "bigint.toF64" | "bigint.asUintN" | "bigint.asIntN" | "bigint.bufferRead" | "bigint.bufferWrite" | "bigint.dataViewGet" | "bigint.dataViewSet"
 /** fs.statSync → a Stats value (may throw, like the other sync fs
  * calls); the stats.* getters are pure reads on it. */
  | "fs.statSync" | "stats.isFile" | "stats.isDirectory" | "stats.size"
@@ -1829,10 +1870,9 @@ export type IrLibFn =
  * the backend (the envGet convention). Never throws. */
  | "spawnRes.error"
 /** child_process.spawn (scr_child.c + the scr_async.c loop): posix_spawnp
- * with stdio "ignore" (all three fds on /dev/null — the only supported
- * stdio; "pipe"/"inherit" are frontend-fenced), the child registered
- * with the event loop, which polls waitpid(WNOHANG) at quiescence like
- * timers (kqueue is the follow-up; SEMANTICS.md documents the polling).
+ * with per-slot ignore/inherit/pipe modes (and number output fds), the
+ * all-piped Node default, and the child registered with the event loop,
+ * which polls waitpid(WNOHANG) at quiescence like timers.
  * NEVER throws: spawn failure defers to the "error" event, Node-exact
  * (the error message is Node's "spawn <cmd> <ERRNO-NAME>"; an "error"
  * event with no listener prints it and exits 1 like an EventEmitter).
@@ -1880,6 +1920,11 @@ export type IrLibFn =
  * the child's 'exit' (the pinned ordering). A flowing stream keeps the
  * loop alive: usesTimers. */
  | "child.stdout" | "child.stderr" | "stream.onData" | "stream.onEnd"
+/** The piped-input writer (stdio mode 3 on fd 0). child.stdin answers
+ * `Writable | null`; writes copy borrowed data into the nonblocking
+ * queue, end/destroy settle it, writable is a pure state read, and
+ * listener callbacks move into the writer registry. */
+ | "child.stdin" | "writer.writeString" | "writer.writeBytes" | "writer.end" | "writer.destroy" | "writer.writable" | "writer.onDrain" | "writer.onFinish" | "writer.onError"
 /** The first-class WritableStream write (`output.write(line)` — the
  * prefixStream idiom): the receiver IS the fd scalar (process.stdout/
  * stderr reads mint 1/2), dispatched onto the exact stdoutWrite/
@@ -2322,18 +2367,19 @@ export type IrLibFn =
  * these are in the may-throw seed. readFile is utf8-fenced like
  * readFileSync. The non-interleaving divergence is documented in
  * SEMANTICS.md. */
-/** node:crypto, the string-producing slice: randomUUID (never throws)
- * and the COMPOSED randomBytes(n).toString("hex"|"base64") — one
- * libCall, the Buffer never escapes (bare randomBytes is fenced).
- * randomBytesToString THROWS Node's RangeError on out-of-range sizes. */
+/** node:crypto randomness: randomUUID plus randomBytes as either a real
+ * Buffer or the fused randomBytes(n).toString("hex"|"base64") path.
+ * The size-taking forms throw Node's RangeError on invalid values. */
  | "crypto.randomUUID" | "crypto.randomBytesToString"
-/** The COMPOSED hash chain createHash(alg).update(data).digest(enc)
- * fused into one call — the Hash handle never materializes. Args are
- * (alg, data, enc); alg is "sha256" | "sha1" and enc "hex" | "base64",
- * both compile-time literals (frontend-fenced). Strings hash their
- * UTF-8 bytes (Node's default input encoding); the bytes form hashes a
- * Buffer/typed array's bytes. Pure; never throw. */
+/** The fused createHash(alg).update(data).digest(enc) fast path and the
+ * one-shot crypto.hash implementation. First-class Hash/Hmac handles use
+ * the entries below; all paths share the incremental runtime core. */
  | "crypto.hashDigestStr" | "crypto.hashDigestBytes"
+/** First-class static Hash/Hmac handles. Constructors validate the
+ * runtime algorithm string (md5/sha1/sha256); update returns the same
+ * handle by retained identity, copy snapshots Hash state, and digest
+ * finalizes the handle and returns either a Buffer or encoded string. */
+ | "crypto.hashNew" | "crypto.hmacNewStr" | "crypto.hmacNewBytes" | "crypto.hashUpdateStr" | "crypto.hashUpdateBytes" | "crypto.hmacUpdateStr" | "crypto.hmacUpdateBytes" | "crypto.hashCopy" | "crypto.hashDigestString" | "crypto.hashDigestBuffer" | "crypto.hmacDigestString" | "crypto.hmacDigestBuffer" | "crypto.timingSafeEqual" | "crypto.randomFill" | "crypto.randomFillRest" | "crypto.randomInt" | "crypto.pbkdf2" | "crypto.randomBytesCb" | "crypto.pbkdf2Cb"
 /** crypto.randomBytes(n) → a real u8 Buffer (+1). THROWS Node's
  * RangeError on out-of-range sizes, exactly like the composed
  * randomBytesToString (which keeps its one-libCall lowering — the two
@@ -2855,7 +2901,11 @@ export type IrLibFn =
  * error. The Dyn twin boxes chunks by runtime tag (the JS lane).
  * readable.fromArr is Readable.from(array): a fully-seeded object-
  * entry stream (one whole chunk per element; strings per the flag). */
- | "readable.nextChunk" | "readable.nextChunkDyn" | "readable.fromArr" | "readable.isPaused" | "readable.pipe" | "readable.unpipe" | "readable.flowing" | "writable.write" | "writable.writeStr" | "writable.writeU" | "writable.writeDyn" | "writable.end" | "writable.cork" | "writable.uncork" | "stream.destroy" | "stream.destroyErr" | "stream.prop" | "stream.errored"
+ | "readable.nextChunk" | "readable.nextChunkDyn" | "readable.fromArr" | "readable.isPaused" | "readable.pipe" | "readable.unpipe" | "readable.flowing" | "writable.write" | "writable.writeStr" | "writable.writeU" | "writable.writeDyn" | "writable.end" | "writable.cork" | "writable.uncork" | "stream.destroy" | "stream.destroyErr"
+/** AsyncIteratorClose for Readable[Symbol.asyncIterator](): destroy with
+ * Node's AbortError/ABORT_ERR payload while the iterator's internal error
+ * consumer prevents an unhandled-error crash. */
+ | "stream.iteratorClose" | "stream.prop" | "stream.errored"
 /** The underscore-method assignment surface (`r._read = fn` after
  * construction — Node's own-property shadow of the prototype method):
  * args [stream receiver (borrowed), callback closure (+1 moves)]. The
@@ -2883,8 +2933,8 @@ export type IrLibFn =
  *
  * assert.ok: (pass, message) — the frontend computed the truthiness AND
  * the full message (the user's, or the compile-time source-text form —
- * assert.fail lowers here too with pass=false). assert.eqF64/eqStr/
- * eqBool: (a, b, negated, deep, msg, hasMsg) — Object.is comparison,
+ * assert.fail lowers here too with pass=false). assert.eqF64/eqBigInt/
+ * eqStr/eqBool: (a, b, negated, deep, msg, hasMsg) — Object.is comparison,
  * covering strictEqual/notStrictEqual and the scalar deepStrictEqual
  * pair; msg is a typed dummy ("" literal) when hasMsg is false (Node
  * distinguishes an omitted message from an empty one per operator).
@@ -2930,7 +2980,7 @@ export type IrLibFn =
  * the value's inspection) — the frontend routes null/undefined to a
  * no-op and everything else here (Node throws for falsy values too).
  * All arguments are borrowed. */
- | "assert.ok" | "assert.eqF64" | "assert.eqStr" | "assert.eqBool" | "assert.eqSym" | "assert.eqDyn" | "assert.deepResult" | "assert.sameValue" | "assert.deqEnter" | "assert.deqLeave" | "assert.match" | "assert.throwsNone" | "assert.throwsMismatch" | "assert.throwsRegex" | "assert.shapeBegin" | "assert.shapeStr" | "assert.shapeRe" | "assert.shapeEnd" | "assert.regexErrTest" | "assert.unwantedRejection"
+ | "assert.ok" | "assert.eqF64" | "assert.eqBigInt" | "assert.eqStr" | "assert.eqBool" | "assert.eqSym" | "assert.eqDyn" | "assert.deepResult" | "assert.sameValue" | "assert.deqEnter" | "assert.deqLeave" | "assert.match" | "assert.throwsNone" | "assert.throwsMismatch" | "assert.throwsRegex" | "assert.shapeBegin" | "assert.shapeStr" | "assert.shapeRe" | "assert.shapeEnd" | "assert.regexErrTest" | "assert.unwantedRejection"
 /** Node's expectsError over an error-INSTANCE expected (assert.throws/
  * rejects second argument): walk the expected dyn error's keys (name,
  * message, code — the %error marker skipped) and deep-compare each
@@ -3389,8 +3439,8 @@ export type IrExpr =
     type: IrType;
     loc: SrcLoc;
 }
-/** JS ToBoolean: f64 is false iff 0, -0, or NaN; string is false iff empty.
- * Operand is f64|string (bool needs no conversion) or a UNION — the ARM
+/** JS ToBoolean: f64 is false iff 0, -0, or NaN; string is false iff empty;
+ * dyn asks its runtime kind. The other operand form is a UNION — the ARM
  * value's ToBoolean via a per-union interned helper (unit arms false;
  * f64/string/bool arms per-value; ref arms — arrays, records, objects,
  * functions, maps, sets, promises, ... — always true; jsval arms ask the
@@ -3859,6 +3909,7 @@ export type IrExpr =
  | {
     kind: "yieldExpr";
     value: IrExpr | null;
+    awaited?: true;
     type: IrType;
     loc: SrcLoc;
 }
@@ -3877,8 +3928,9 @@ export type IrExpr =
  * unless suspended (then the GENRET unwind runs finallys; a finally
  * yield answers done:false and parks the return value) / throw on a
  * non-suspended generator marks it done and re-throws at the call site.
- * MAY-THROW SEED: a body exception (or the injected throw) propagates
- * into the caller synchronously. */
+ * Sync generators return that record directly and propagate body errors
+ * synchronously. Async generators return Promise<record>; requests queue,
+ * and body errors reject the corresponding promise. */
  | {
     kind: "genResume";
     mode: "next" | "return" | "throw";
@@ -4158,12 +4210,13 @@ export type IrExpr =
  * TypeError), the interned signature key (dynCheck's exact-unwrap fast
  * path), and `fnName` — the best-effort static spelling for inspect
  * ([Function: name]) and Node-shaped call errors. The operand is
- * borrowed; the result is owned (+1). Never throws. `liveRef` is the
- * narrow Web-platform exception for record/array/bytes values (including
- * mutable arms selected at runtime from a union) whose API contract
- * exposes the same reference again (stream chunks and abort reasons): it
- * emits a typed capsule with a live materializer instead of the ordinary
- * deep copy. */
+ * borrowed; the result is owned (+1). Never throws. Program class
+ * instances always use a typed capsule so an exact checked cast recovers
+ * the original identity. `liveRef` requests the same capsule form for
+ * record/array/bytes values (including mutable arms selected at runtime
+ * from a union) whose Web API contract exposes the reference again, such
+ * as stream chunks and abort reasons; ordinary JSON-shaped values retain
+ * the documented deep-copy boundary. */
  | {
     kind: "dynFrom";
     value: IrExpr;
@@ -4935,10 +4988,22 @@ export declare const DYN_HANDLE_KINDS: ReadonlyMap<string, {
     tag: string;
     cls: string;
 }>;
+/** A class value that crosses an `unknown` slot as a compiler-owned typed
+ * reference. %Error keeps its dedicated error encoding; every other class
+ * preserves the original object identity and exposes a materialized own-field
+ * view only when a checked-dynamic operation actually needs one. */
+export declare function isDynTypedRefType(t: IrType): t is Extract<IrType, {
+    kind: "object";
+}>;
+/** Whether a class layout field is an ECMAScript own enumerable property.
+ * `#private` slots and `%`-prefixed compiler storage exist only in the native
+ * layout; TypeScript `private`/`protected` fields keep ordinary names and are
+ * observable properties at runtime. */
+export declare function isClassOwnEnumerableFieldName(name: string): boolean;
 /** A static type that CONVERTS into a dyn value — the dynFrom domain:
- * JSON-safe data, bytes<u8> (payload copied), undefined-armed unions of
- * JSON-safe arms, boxable function types, and the runtime HANDLE kinds
- * (boxed by reference — DYN_HANDLE_KINDS). */
+ * JSON-safe data, bytes<u8> (payload copied), identity-preserving class
+ * references, undefined-armed unions of those arms, boxable function types,
+ * and the runtime HANDLE kinds (boxed by reference — DYN_HANDLE_KINDS). */
 export declare function canConvertToDyn(t: IrType, getRecord: (shapeId: string) => IrRecordShape | undefined, getUnion: (unionId: string) => IrUnionDef | undefined): boolean;
 /** A type a dyn value can be VALIDATED into — the dynCheck domain:
  * JSON-safe data, bytes<u8> (a fresh copy out), the %Error extraction,
@@ -5080,6 +5145,10 @@ export declare function moduleUsesDynInvoke(mod: IrModule): boolean;
  * walk shape as moduleUsesZlib. */
 export declare function moduleUsesDynAsync(mod: IrModule): boolean;
 export declare function moduleUsesInspect(mod: IrModule): boolean;
+/** True when the module reaches child_process or carries one of its runtime
+ * handle/result types. Besides the existing link consequence, this gates the
+ * checked-dynamic ChildProcess handle table installed from scr_child.c. */
+export declare function moduleUsesChildProcess(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 (native-toolchain.ts + emitter; the scr_events gating precedent).
@@ -5094,6 +5163,10 @@ export declare function moduleUsesNet(mod: IrModule): boolean;
  * fence still emits release calls that need the unit linked. Symbol-free
  * programs pay zero bytes and keep their exact link line. */
 export declare function moduleUsesSymbol(mod: IrModule): boolean;
+/** True when bigint runtime operations or bigint-typed storage appears in
+ * the IR. The type check keeps retain/release references link-safe even
+ * when a producing statement was replaced by a runtime fence. */
+export declare function moduleUsesBigInt(mod: IrModule): boolean;
 /** True when the module uses the URLSearchParams surface — sp.* libCalls,
  * the url.searchParams getter, or a searchParams-kind type anywhere on
  * the IR (a fenced statement can leave a typed local whose release call