@scriptc/compiler 0.3.1 → 0.3.3

package/dist/ir/ir.d.ts

@@ -119,7 +119,8 @@ export type IrType = {
  * elements (SCR_ELEM_REF identity semantics, the child precedent), and
  * Set elements (identity hashing, SCR_MAP_KEY_REF — the netServer
  * precedent); fenced out of map keys/values and JSON (JSON.stringify
- * drops symbols in Node — silent divergence banned, reject instead).
+ * drops symbols in Node — rejected instead of diverging without a
+ * diagnostic).
  * Property KEYS stay frontend-fenced: static record/class shapes have
  * no symbol-keyed storage. */
  | {
@@ -140,6 +141,13 @@ export type IrType = {
  | {
     kind: "fileHandle";
 }
+/** An fs.Dir (opendirSync / fs.promises.opendir): heap, refcounted,
+ * MUTABLE — aliases share one directory stream, read an entry at a time;
+ * close() closes it for every alias, and the final release closes a
+ * still-open stream. Holds no references and cannot be part of a cycle. */
+ | {
+    kind: "dir";
+}
 /** A child_process.spawnSync result (scr_child.c): heap, refcounted,
  * IMMUTABLE — the reaped child's status plus its captured utf8 stdout/
  * stderr. Holds only strings — never part of a cycle, no trace. Same
@@ -414,13 +422,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", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "procStream"];
+declare const HANDLE_KIND_LIST: readonly ["stats", "fileHandle", "dir", "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<"child" | "childStream" | "childWriter" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
+export declare const HANDLE_KINDS: IrKindSet<"child" | "childStream" | "childWriter" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dir" | "fileHandle" | "fsWatcher" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "netServer" | "netSocket" | "procStream" | "secureCtx" | "spawnRes" | "stats" | "testCtx">;
 /** The IR kinds represented as pointers in native code. */
-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", "moduleNs", "record", "union", "dyn", "caught", "promise", "generator"];
+declare const POINTER_KIND_LIST: readonly ["string", "bigint", "array", "map", "set", "regex", "bytes", "url", "searchParams", "symbol", "stats", "fileHandle", "dir", "spawnRes", "child", "netServer", "netSocket", "http2Session", "http2Stream", "dgramSocket", "testCtx", "httpReq", "httpRes", "httpClientReq", "secureCtx", "cryptoHash", "cryptoHmac", "fsWatcher", "childStream", "childWriter", "func", "object", "classval", "moduleNs", "record", "union", "dyn", "caught", "promise", "generator"];
 export type PointerKind = (typeof POINTER_KIND_LIST)[number];
-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" | "map" | "moduleNs" | "netServer" | "netSocket" | "object" | "promise" | "record" | "regex" | "searchParams" | "secureCtx" | "set" | "spawnRes" | "stats" | "string" | "symbol" | "testCtx" | "union" | "url">;
+export declare const POINTER_KINDS: IrKindSet<"array" | "bigint" | "bytes" | "caught" | "child" | "childStream" | "childWriter" | "classval" | "cryptoHash" | "cryptoHmac" | "dgramSocket" | "dir" | "dyn" | "fileHandle" | "fsWatcher" | "func" | "generator" | "http2Session" | "http2Stream" | "httpClientReq" | "httpReq" | "httpRes" | "map" | "moduleNs" | "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
@@ -446,6 +454,7 @@ export declare const SEARCH_PARAMS_T: IrType;
 export declare const SYMBOL_T: IrType;
 export declare const STATS_T: IrType;
 export declare const FILEHANDLE_T: IrType;
+export declare const DIR_T: IrType;
 export declare const SPAWNRES_T: IrType;
 export declare const CHILD_T: IrType;
 export declare const NETSERVER_T: IrType;
@@ -565,6 +574,10 @@ export interface IrModule {
     entry: string;
     /** Executable roots run in isolated native worker contexts. */
     workers?: boolean;
+    /** The program constructs LifetimeRegion (@scriptc/experimental): every
+     * ProgramLifetime instance lives in a counted region (the region.*
+     * intrinsics; backend/llvm/regions.ts). */
+    lifetimeRegions?: true;
     /** The entry module is CommonJS under Node's classification. Node runs a
      * CommonJS main synchronously and drains process.nextTick callbacks
      * before promise jobs at the first checkpoint; an ES-module main's
@@ -754,7 +767,7 @@ export interface IrLibSection {
     /** The host-callback registration symbol; present exactly when
      * `callbacks` is (the profile pairs them — SC4001 otherwise). Both
      * fields stay ABSENT on callback-free profiles so their serialized IR
-     * and emitted TU are unchanged byte-for-byte. */
+     * and emitted TU stay identical. */
     callbackRegisterSymbol?: string;
     /** The resolved host-callback channels, slot-ordered. */
     callbacks?: IrLibCallback[];
@@ -846,6 +859,10 @@ export interface IrClassDef {
      * `get:<prop>` / `set:<prop>` entries — names no user identifier can
      * spell — and behave as ordinary methods here. */
     methods?: string[];
+    /** String names of the methods and accessors this class declares on its
+     * prototype (not inherited), independent of method reachability. A
+     * reflective `in` over an instance seen as `unknown` answers them. */
+    prototypeNames?: string[];
     /** Declared `abstract class` — never instantiated (tsc rejects `new` on
      * it, including through class values), so its own vtable entries for
      * abstract slots may stay empty. */
@@ -907,6 +924,18 @@ export declare const RUNTIME_STREAM_CLASSES: ReadonlyMap<string, {
     base: string;
     sides: "r" | "w" | "rw";
 }>;
+/** The runtime-provided EventTarget and Event bases of compiled
+ * subclasses (`class Bus extends EventTarget`, `class Ping extends
+ * Event`; scr_event_target.c, link-gated with the rest of the EventTarget
+ * surface). Plain `new EventTarget()` / `new Event()` values stay
+ * checked-dynamic handles; these classes exist only as roots of program
+ * hierarchies. Like the emitter, backends emit no struct/RC/vtable for
+ * them: subclass structs embed the runtime prefix (the engine-state
+ * pointer created by super() and the display-name slot stamped by the
+ * emitted allocation), and the instances' checked-dynamic capsules use
+ * the runtime RC adapters, which is how the engine recognizes them. */
+export declare const RUNTIME_EVENT_TARGET_CLASS = "%EventTarget";
+export declare const RUNTIME_EVENT_CLASS = "%Event";
 export interface IrRecordShape {
     /** Frontend-assigned shape id (`r0`, `r1`, ...). */
     id: string;
@@ -950,6 +979,9 @@ export interface IrRecordShape {
      * %dtype) — hidden from every key-order surface, JSON included. */
     declaredOrder?: string[];
 }
+/** fs.Dirent rows: the hidden %dtype entry kind (libuv's UV_DIRENT
+ * encoding), then name and parentPath (type-mapper's interned shape). */
+export declare function isDirentShape(shape: IrRecordShape): boolean;
 /** Codec records have private native state, not a structurally checkable
  * data surface. Reserve the same '%' namespace as other internal slots. */
 export declare function recordTextCodecClass(shape: IrRecordShape): "TextEncoder" | "TextDecoder" | null;
@@ -1057,6 +1089,9 @@ export interface IrParam {
     localId: string;
     name: string;
     type: IrType;
+    /** Callers pass an owned reference, which the body holds for its whole
+     * run, even when the parameter is never rebound. */
+    owned?: true;
 }
 export interface IrGlobal {
     /** "%g.<qualifier>.<name>" — distinct namespace from local ids. */
@@ -1255,9 +1290,15 @@ export type IrStmt =
     body: IrStmt[];
     labels?: string[];
     loc: SrcLoc;
-} | {
+}
+/** `awaited`: a return of an async generator that needs no Await of its
+ * own — its operand's await performed it (`return p` of a promise), or
+ * it has no operand (`return;`). The request settles as the body
+ * completes instead of one microtask turn later. */
+ | {
     kind: "return";
     value: IrExpr | null;
+    awaited?: true;
     loc: SrcLoc;
 }
 /** Field write `obj.f = v` — statement-only, like `assign`/`arraySet`.
@@ -1360,9 +1401,10 @@ export type IrStmt =
  * construct has no static lowering, and JS carries no annotations to
  * change that — so the fence fires when the statement RUNS instead of
  * failing the build (the JS-input design: inference gaps land where
- * `any` lands — honest fences, never silent misbehavior). Executing it
- * throws a catchable Error whose message names the construct and whose
- * `code` carries the SC diagnostic code; unwinds exactly like `throw`.
+ * `any` lands — a runtime fence instead of undiagnosed misbehavior).
+ * Executing it throws a catchable Error whose message names the construct
+ * and whose `code` carries the SC diagnostic code; unwinds exactly like
+ * `throw`.
  * TypeScript sources produce it only as the tsc-unreachable fallthrough
  * trap (appendImplicitUndefinedReturn's SC9002) — their construct fences
  * stay compile errors. */
@@ -1420,7 +1462,13 @@ export type IrArrIntrinsicMethod =
  * arguments are [value count, comparator]. Every slot below the count is
  * a value of an `isSortValuesElement` type; the comparator is invoked
  * with exactly its declared arity. Returns void; comparator exceptions
- * propagate and leave the snapshot unchanged. */
+ * propagate and leave the snapshot unchanged. Optional trailing
+ * arguments [order, key] describe a comparator that orders numbers
+ * ascending (order 1) or descending (-1), a numeric literal: the runtime
+ * may then sort by key without calling it. Number elements are their own
+ * keys; record and class elements pass the capture-free key reader
+ * `(elem) => number` both comparator operands apply. Keys the runtime
+ * does not order directly (NaN, -0) still sort through the comparator. */
  | "sortValues"
 /** Internal stable comparator sort of a dense array in place: arguments
  * are [comparator, owned]. Returns false, without calling the comparator,
@@ -1428,7 +1476,8 @@ export type IrArrIntrinsicMethod =
  * is published; the caller then sorts a compacted snapshot. Otherwise the
  * receiver's values are sorted outside it and written back only after
  * success, as the spec's sort writes them, and it returns true. `owned`
- * (a boolean literal) marks a private copy no user code can reach. */
+ * (a boolean literal) marks a private copy no user code can reach.
+ * Optional trailing arguments [order, key] as for sortValues. */
  | "sortDense" | "length"
 /** Internal ToNumber(a[index]) for f64-backed arrays: one numeric index,
  * returning the stored number or NaN for a hole/undefined/missing key.
@@ -1476,13 +1525,16 @@ export declare function isSortValuesElement(elem: IrType, unionArms?: readonly I
  * members are compiler-internal: no ambient declaration reaches them. */
 export type IrMapIntrinsicMethod = 
 /** Internal shallow-copy constructors over builtin collection storage. */
-"clone" | "keySet" | "valueSet" | "get" | "set" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterValue" | "iterEnter" | "iterExit";
+"clone" | "keySet" | "valueSet" | "get" | "set" | "has" | "delete" | "size" | "clear" | "iterCount"
+/** The first live index, or iterCount when none is live
+ * (scr_map_iter_start). for-of starts its index there. */
+ | "iterStart" | "iterLive" | "iterKey" | "iterValue" | "iterEnter" | "iterExit";
 /** The Set method/property surface — Map's minus get/set/iterValue (there
  * is no value slot; `add` fills set's role) plus `add`. `forEach` desugars
  * in the frontend exactly like Map's, over the same iteration primitives —
  * iterKey doubles as the element read (JS's Set forEach passes the element
  * as both `value` and `key`). */
-export type IrSetIntrinsicMethod = "clone" | "add" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterLive" | "iterKey" | "iterEnter" | "iterExit"
+export type IrSetIntrinsicMethod = "clone" | "add" | "has" | "delete" | "size" | "clear" | "iterCount" | "iterStart" | "iterLive" | "iterKey" | "iterEnter" | "iterExit"
 /** `[...set]` and friends: drain the live entries into a FRESH elem[]
  * in insertion order (tombstones skipped — the same walk the forEach
  * desugar does, folded into one runtime call; no user code runs during
@@ -1497,7 +1549,7 @@ export type IrSetIntrinsicMethod = "clone" | "add" | "has" | "delete" | "size" |
  * regexIntrinsic): args[0] is the separator and args[1] the numeric limit
  * (an omitted source limit is completed to 2^32-1), result a fresh +1
  * string[] — the empty separator splits per UTF-16 code unit (astral
- * halves become U+FFFD, divergence 2). `padStart`/`padEnd` take (target
+ * halves become lone surrogates). `padStart`/`padEnd` take (target
  * length, fill) — the frontend completes an omitted fill to " ", Node's
  * default. `trimStart`/`trimEnd` are trim's one-sided halves. */
 export type IrStrIntrinsicMethod = "length" | "charCodeAt" | "charAt" | "indexOf" | "includes" | "startsWith" | "endsWith" | "slice" | "substring" | "repeat" | "trim" | "trimStart" | "trimEnd" | "split" | "padStart" | "padEnd" | "toLowerCase" | "toUpperCase" | "normalize" | "isWellFormed" | "toWellFormed" | "cpAt";
@@ -1554,6 +1606,19 @@ export type IrBytesIntrinsicMethod = "buffer" | "length" | "byteLength" | "get"
 /** In-place overlapping copy, [target, start, end] relative indices;
  * returns the receiver (+1). */
  | "copyWithin"
+/** In-place numeric sort, [order]: a numeric literal 0 for the default
+ * TypedArray order (NaN last, -0 before +0), or 1 / -1 for a recognized
+ * ascending / descending numeric comparator. Returns true when sorted;
+ * a comparator order answers false, having written nothing, for a NaN
+ * or -0 float element, and the caller sorts through the comparator.
+ * Runs no script code. */
+ | "sortNumeric"
+/** In-place comparator sort, [comparator]: a `(number, number) =>
+ * number` function of at most two parameters, called with the comparison
+ * schedule of Node's typed-array sort over a snapshot that is written
+ * back after the last comparison. Returns void; a comparator exception
+ * propagates and leaves the receiver unwritten. */
+ | "sortCompare"
 /** Fresh Uint8Array copying methods. `with` takes [index, value] and
  * throws a catchable RangeError for an invalid relative index. */
  | "toReversed" | "with"
@@ -1618,7 +1683,16 @@ export type IrRegexIntrinsicMethod = "test" | "match"
  * as read (k < 53). Unmarked captures read as undefined and the result
  * carries no index/input properties; the match, lastIndex transitions
  * and null result are exec's. */
- | "execGroups" | "lastIndex"
+ | "execGroups"
+/** execGroups whose args[2] (a numeric literal, a subset of args[1])
+ * marks the captures read only through the regex.groupEquals/
+ * groupNumber/groupParseInt libCalls; the runtime may keep those as
+ * spans of the subject rather than strings. */
+ | "execSpans"
+/** `s.match(re)` read like an execGroups result: a global regex answers
+ * match's whole-match array; otherwise execSpans with args[1], args[2]
+ * (args[2] is 0 until regex span folding marks lazy captures). */
+ | "matchGroups" | "lastIndex"
 /** `s.matchAll(re)` — every match as its honest string[] slice (match's
  * rule), drained EAGERLY into a fresh string[][]: the lazy iterator is
  * unobservable across the lowered surface (strings are immutable; the
@@ -1732,8 +1806,8 @@ export type IrExpr =
  * 0)`. f64 fields compute in place (JS-exact); fieldDyn marks a
  * CHECKED-DYNAMIC field (a JS implicit-any ctor assignment): the number
  * validates OUT of the box (dynCheck's catchable TypeError on
- * non-numbers — the documented dyn arithmetic stance, never a silent
- * ToNumber), computes, and boxes back into the slot (old box released
+ * non-numbers — the documented dyn arithmetic stance, instead of an
+ * implicit ToNumber), computes, and boxes back into the slot (old box released
  * after the unlink, like fieldSet). Type is always f64. */
  | {
     kind: "fieldIncDec";
@@ -2240,11 +2314,14 @@ export type IrExpr =
  * as the GENRET sentinel — pending like an exception, it unwinds
  * through finally blocks but must NOT be taken by catch handlers
  * (backends emit a sentinel re-unwind prologue at catch entry inside
- * generator bodies; scr_exc_genret_pending answers it). */
+ * generator bodies; scr_exc_genret_pending answers it). `delegated`:
+ * only as the `arg` of a `delegate` genResume, which reads the resumed
+ * value and handles a pending throw or return; the yield itself is VOID. */
  | {
     kind: "yieldExpr";
     value: IrExpr | null;
     awaited?: true;
+    delegated?: true;
     captureCompletion?: {
         returnType: IrType;
     };
@@ -2274,13 +2351,27 @@ export type IrExpr =
  * generator (for-of, spread, yield*), which read only `done` and then the
  * yielded value: `step` is a valueless next() answering `done` (BOOL;
  * throws like next); `value` moves the yielded value out, typed as the
- * yield channel (valid only right after a `step` that answered false;
- * never throws); `close` is a valueless return() whose result is dropped
+ * yield channel (valid only right after a `step` or `delegate` that
+ * answered false; never throws), or the completion value typed as the
+ * return channel (once a `delegate` answered true); `close` is a valueless return() whose result is dropped
  * (IteratorClose; VOID; throws like return). All three have a null
- * `arg`. */
+ * `arg`.
+ *
+ * `delegate` drives a sync generator from a `yield*` in a sync generator
+ * body. With a null `arg` it is the delegation's first resume: a
+ * valueless next() on any next channel (a suspended delegate whose next
+ * channel is typed throws an SC1071 fence error instead). Otherwise `arg`
+ * is a `delegated` yieldExpr, and once the body resumes, the consumer's
+ * next(v), return(v), or throw(e) passes to the delegate; the body
+ * itself unwinds only on a delegate exception or when the delegate
+ * completes a forwarded return(). The delegate's next channel is
+ * undefined, dyn, or the body's own. The result is the delegate's
+ * IteratorResult record, or BOOL `done` for a record-free drive (then
+ * `value` reads a yielded value or the completion; an empty completion
+ * on a valued return channel throws an SC1071 fence error). */
  | {
     kind: "genResume";
-    mode: "next" | "return" | "throw" | "step" | "value" | "close";
+    mode: "next" | "return" | "throw" | "step" | "value" | "close" | "delegate";
     gen: IrExpr;
     arg: IrExpr | null;
     type: IrType;
@@ -2478,20 +2569,12 @@ export type IrExpr =
  * shape (their values have the shape's indexValue type — dyn included);
  * they insert into the overflow map in list order, interleaved with the
  * declared writes (one list keeps JS source-order evaluation). */
-/** Entries flagged `drop` are fields the shape MAPPING dropped (the
- * PromiseSettledResult honest subset — SEMANTICS.md 46): the value
- * expression still evaluates in its source-order slot (the awaited
- * mapper in `{ status: "fulfilled", value: await fn(...) }` must run and
- * may throw), but nothing is stored — the emitter releases the result
- * with the statement frame. Any value type is legal here, void included
- * (an awaited Promise<void>). */
  | {
     kind: "recordLit";
     fields: {
         name: string;
         value: IrExpr;
         overflow?: true;
-        drop?: true;
     }[];
     type: IrType;
     loc: SrcLoc;
@@ -2621,10 +2704,10 @@ export type IrExpr =
 /** Prototype-method DISPATCH on a dyn receiver — `recv.m(...)` where `m`
  * is a name a dyn-representable prototype declares (Array/String/
  * Function shared names: push, slice, join, forEach, map, apply, ...),
- * so a stored-member read would silently mis-answer real methods. The
+ * so a stored-member read would return wrong results for real methods. The
  * runtime (scr_dyn_invoke) dispatches on the receiver's KIND:
  * implemented (kind, name) pairs run JS-exact semantics; a real-but-
- * unimplemented method throws a LOUD "not supported yet" Error; a name
+ * unimplemented method throws a "not supported yet" Error; a name
  * the kind's prototype lacks throws Node's catchable "<calleeName> is
  * not a function"; OBJ receivers call the own member (own properties
  * shadow prototypes in JS too); undefined/null receivers throw Node's
@@ -3083,11 +3166,17 @@ export type IrExpr =
  * promise.race: every arg is a PROMISE (the array literal's
  * entries, lowered individually — the array never materializes), the
  * type is the checker's combined result promise; the backend emits a
- * fresh promise plus one scr_promise_race_add per entry with an
+ * fresh promise plus one scr_promise_race_join per entry with an
  * interned per-(entry-inner → result-inner) adapter (raceAdapterFor) —
  * same-type entries share the runtime's copy adapter, arm entries wrap
  * into the result union, sub-union entries re-tag arm-wise. First
  * settle wins; rejections copy raw and count handled on the entry.
+ * promise.allSettled / promise.any: ONE arg, an array of promises
+ * (Promise.all's countdown machinery). allSettled's type is a promise
+ * of the PromiseSettledResult union array — the backend's per-entry
+ * store adapter builds the fulfilled/rejected record arm; any's type is
+ * the entries' own promise type (the first fulfillment copies through;
+ * exhaustion rejects with an AggregateError of the dyn reasons).
  * promise.reject: one %Error-rooted arg (the reason — rejection
  * payloads share the thrown-Error representation), type is the
  * context-named result promise; the backend mints a fresh promise and
@@ -3105,7 +3194,7 @@ export type IrExpr =
  * (a module binding of an import cycle read before its declaration). */
  | {
     kind: "intrinsic";
-    name: "console.log" | "console.error" | "promise.race" | "promise.all" | "promise.reject" | "promise.resolve" | "module.await" | "module.tdzCheck" | "threads.publish";
+    name: "console.log" | "console.error" | "promise.race" | "promise.all" | "promise.allSettled" | "promise.any" | "promise.reject" | "promise.resolve" | "module.await" | "module.tdzCheck" | "threads.publish" | "region.create" | "region.enter" | "region.leave" | "region.release";
     args: IrExpr[];
     type: IrType;
     loc: SrcLoc;
@@ -3134,7 +3223,7 @@ export type IrExpr =
  * type must be JSON-safe (f64/string/bool/record/array/union of those,
  * recursively — validated), and backends emit one serializer per type used
  * in stringify position (interned, like the array-HOF desugars) instead of
- * walking any runtime tag. Output is Node-compatible byte-for-byte with
+ * walking any runtime tag. Output is identical to Node's with
  * ONE documented divergence: record fields serialize in canonical (sorted)
  * order, not insertion order (SEMANTICS.md). NaN/±Infinity stringify as
  * `null` and -0 as `0`, exactly like JS; a record field holding the
@@ -3169,10 +3258,14 @@ export type IrExpr =
  * corrupting memory). `preserveRefs` refuses structural copies of native
  * references, including references nested in newly materialized arrays or
  * tuples; collection seeds use it to preserve key identity. */
+/** `exact`: the value is known to be a capsule this program boxed from
+ * exactly the class `type` names (a `dyn.typedRefKeyIs` test guards the
+ * expression), so the check is one load of the capsule's instance. */
  | {
     kind: "dynCheck";
     value: IrExpr;
     preserveRefs?: true;
+    exact?: true;
     type: IrType;
     loc: SrcLoc;
 };

package/dist/ir/ir.js

@@ -28,6 +28,7 @@ export const BYTES_ELEMENT_NAME = {
 const POINTER_HANDLE_KINDS = [
     "stats",
     "fileHandle",
+    "dir",
     "spawnRes",
     "child",
     "netServer",
@@ -98,6 +99,7 @@ export const RUNTIME_RC_STEMS = {
     symbol: "scr_sym",
     stats: "scr_stats",
     fileHandle: "scr_file_handle",
+    dir: "scr_dir",
     spawnRes: "scr_spawn_res",
     child: "scr_child",
     netServer: "scr_net_server",
@@ -140,6 +142,10 @@ export function runtimeRcStem(t) {
             return "scr_emitter";
         if (RUNTIME_STREAM_CLASSES.has(t.className))
             return "scr_stream";
+        if (t.className === RUNTIME_EVENT_TARGET_CLASS)
+            return "scr_event_target_obj";
+        if (t.className === RUNTIME_EVENT_CLASS)
+            return "scr_event_obj";
         return null;
     }
     const stem = RUNTIME_RC_STEMS[t.kind];
@@ -162,6 +168,7 @@ export const REF_TRUTHY_KINDS = new Set([
     "searchParams",
     "stats",
     "fileHandle",
+    "dir",
     "spawnRes",
     "child",
     "netServer",
@@ -204,6 +211,7 @@ export const SEARCH_PARAMS_T = { kind: "searchParams" };
 export const SYMBOL_T = { kind: "symbol" };
 export const STATS_T = { kind: "stats" };
 export const FILEHANDLE_T = { kind: "fileHandle" };
+export const DIR_T = { kind: "dir" };
 export const SPAWNRES_T = { kind: "spawnRes" };
 export const CHILD_T = { kind: "child" };
 export const NETSERVER_T = { kind: "netServer" };
@@ -590,6 +598,11 @@ export const RUNTIME_ERROR_CLASSES = new Map([
     ["%ReferenceError", { lib: "ReferenceError", kind: 5, base: "%Error" }],
     ["%EvalError", { lib: "EvalError", kind: 6, base: "%Error" }],
     ["%URIError", { lib: "URIError", kind: 7, base: "%Error" }],
+    // AggregateError — Promise.any's rejection and its own constructor. Its
+    // `errors` list lives in a runtime-side slot beyond the ScrError prefix
+    // (the DOMException arrangement), read through error.aggregateErrors, so
+    // user `extends AggregateError` is fenced too.
+    ["%AggregateError", { lib: "AggregateError", kind: 8, base: "%Error" }],
 ]);
 /** The runtime-provided node:events EventEmitter class (ScrEmitter /
  * scr_emitter_*, scr_events_emitter.c — link-gated by moduleUsesEmitter,
@@ -623,6 +636,31 @@ export const RUNTIME_STREAM_CLASSES = new Map([
     ["%Transform", { lib: "Transform", base: "%Duplex", sides: "rw" }],
     ["%PassThrough", { lib: "PassThrough", base: "%Transform", sides: "rw" }],
 ]);
+/** The runtime-provided EventTarget and Event bases of compiled
+ * subclasses (`class Bus extends EventTarget`, `class Ping extends
+ * Event`; scr_event_target.c, link-gated with the rest of the EventTarget
+ * surface). Plain `new EventTarget()` / `new Event()` values stay
+ * checked-dynamic handles; these classes exist only as roots of program
+ * hierarchies. Like the emitter, backends emit no struct/RC/vtable for
+ * them: subclass structs embed the runtime prefix (the engine-state
+ * pointer created by super() and the display-name slot stamped by the
+ * emitted allocation), and the instances' checked-dynamic capsules use
+ * the runtime RC adapters, which is how the engine recognizes them. */
+export const RUNTIME_EVENT_TARGET_CLASS = "%EventTarget";
+export const RUNTIME_EVENT_CLASS = "%Event";
+/** fs.Dirent rows: the hidden %dtype entry kind (libuv's UV_DIRENT
+ * encoding), then name and parentPath (type-mapper's interned shape). */
+export function isDirentShape(shape) {
+    return (!shape.tuple &&
+        shape.indexValue === undefined &&
+        shape.fields.length === 3 &&
+        shape.fields[0].name === "%dtype" &&
+        shape.fields[0].type.kind === "f64" &&
+        shape.fields[1].name === "name" &&
+        shape.fields[1].type.kind === "string" &&
+        shape.fields[2].name === "parentPath" &&
+        shape.fields[2].type.kind === "string");
+}
 /** Codec records have private native state, not a structurally checkable
  * data surface. Reserve the same '%' namespace as other internal slots. */
 export function recordTextCodecClass(shape) {
@@ -680,6 +718,7 @@ export function isSortValuesElement(elem, unionArms) {
 /** The bytesIntrinsic methods that can raise a catchable error — backends'
  * may-throw analyses seed on these exactly like MAY_THROW_LIB_FNS. */
 export const MAY_THROW_BYTES_METHODS = new Set([
+    "sortCompare",
     "toStringVar",
     "with",
     "setFrom",
@@ -839,7 +878,8 @@ function isJsonSafeAt(t, getRecord, getUnion, stringify, undefinedAllowed, visit
         // sp.toString() instead.
         case "searchParams":
         // Symbols are DROPPED by Node's stringify (undefined at the top level,
-        // omitted as object values) — silent divergence banned; rejected.
+        // omitted as object values) — rejected instead of diverging without a
+        // diagnostic.
         case "symbol":
         case "caught":
         case "promise":
@@ -909,6 +949,7 @@ export const DYN_HANDLE_KINDS = new Map([
     ["http2Session", { tag: "SCR_DYNH_H2_SESSION", cls: "Http2Session" }],
     ["http2Stream", { tag: "SCR_DYNH_H2_STREAM", cls: "Http2Stream" }],
     ["httpClientReq", { tag: "SCR_DYNH_HTTP_CLIENT", cls: "ClientRequest" }],
+    ["dir", { tag: "SCR_DYNH_DIR", cls: "Dir" }],
 ]);
 /** A class value that crosses an `unknown` slot as a compiler-owned typed
  * reference. %Error keeps its dedicated error encoding; every other class