@scriptc/compiler 0.0.0 → 0.0.2

package/dist/backend/emission/emitter.js

@@ -0,0 +1,1249 @@
+import { funcOf, isRefCounted, isUnitType, mapOf, moduleEmbedsCompressedNpm, moduleUsesDgram, moduleUsesDynInvoke, moduleEmbedsBuiltin, moduleUsesFetch, moduleUsesFsWatch, moduleUsesHttp2, moduleUsesHttpServer, moduleUsesNet, moduleUsesNodeTest, moduleUsesProcessEvents, moduleUsesStream, RUNTIME_EMITTER_CLASS, STRING, VOID } from "../../ir/nodes.js";
+import { mangleAsyncSpawn, mangleGenSpawn, mangleClassObj, mangleField, mangleGlobal, mangleFnClosure, mangleFunction, mangleLocal, mangleRawParam, mangleVtSlot, mangleWrapper, } from "../mangle.js";
+import { cType, releaseCallC, cStringLiteral, cDecl } from "./emit-types.js";
+import { computeMayThrow } from "./may-throw.js";
+import { dynDesc, unionTruthyHelper, unionEqHelper, unionToStrHelper, unionJoinHelper, jsonWriteHelper, jsonIndentHelper, dynMatchHelper, dynCheckHelper, dynFuncBoxHelper, dynToStrHelper, caughtToDynHelper, toDynHelper, recordKeyGetHelper, recordKeySetHelper } from "./emit-walkers.js";
+import { emitStructDefs, vtEntriesFor, vtSlotParams, emitVtableDecls, emitVtableInstances, emitVtAdapterDefs, emitHierarchyClassHelpers, emitClassObjs, emitCtorThunkDefs, errorVtStampLines, emitterVtStampLines, streamVtStampLines, traceAdapterC, traceArgC, boxNewC, arrNewC } from "./emit-shapes.js";
+import { emitAsyncScaffolding, childDataThunkFor, childExitThunkFor, childExitThunkFor2, closeBindThunkFor, connectSockThunkFor, closeOverrideWrapFor, dgramMsgThunkFor, dnsLookupThunkFor, netLookupAnswerThunkFor, emitterInvokeThunkFor, streamCbThunkFor, streamDataThunkFor, raceAdapterFor, resolveThunkFor, sniAnswerThunkFor } from "./emit-async.js";
+import { emitNpmEmbedding, islandAdapter, islandTypedAdapter } from "./emit-island.js";
+import { emitFunction, emitBlock, emitStmts, emitStmt, emitTryCatch, emitSwitch, mergeBrace, emitBranchInto, emitCondition } from "./emit-stmts.js";
+import { emitExpr } from "./emit-exprs.js";
+export function emitModule(mod, sourceText) {
+    return new CEmitter(mod, sourceText).emit();
+}
+export class CEmitter {
+    mod;
+    lines = [];
+    indent = 0;
+    tempCounter = 0;
+    /** Interned string literals: UTF-8 text → static symbol name. */
+    literals = new Map();
+    /** Interned unit-armed union instances: "unionId:tag" → static symbol.
+     * A unit arm (undefined/null) has no payload, so every instance of one
+     * (union, tag) pair is identical — ONE immortal (rc == SIZE_MAX) static
+     * serves them all. Immortals are skipped by retain/release and by the
+     * cycle collector's child filter (SCR_CYC_SKIP), so the missing cycle
+     * header is fine even when a traced container points at one. */
+    unitInstances = new Map();
+    /** Interned regex literals: "<flags>/<pattern>" → static symbol. One
+     * immortal (rc == SIZE_MAX) ScrRegex per distinct (pattern, flags) pair —
+     * the bytecode slot starts NULL and the runtime compiles it lazily on
+     * first use. The source/flags strings ride the ordinary literal table. */
+    regexInstances = new Map();
+    /** Interned tagged-template strings objects: per-site key → symbol +
+     * cooked spans. One immortal (rc == SIZE_MAX) ScrArr of interned string
+     * literals per template-literal SITE — the spec's per-occurrence
+     * identity: the same site evaluated twice hands the tag the same array,
+     * two sites never share even with identical text. */
+    templateStringsInstances = new Map();
+    /** Class objects (classes as first-class values): className → static
+     * symbol. One immortal ScrClassObj per class some classRef names —
+     * preorder interval baked as constants, the .name string in the literal
+     * table, and a per-class construct thunk (void *sc_ct_*) newValue
+     * dispatches through. Registered during body emission (the regex
+     * pattern); the statics and thunks are assembled around the bodies. */
+    classObjs = new Map();
+    /** Stack of statement frames: refcounted temps not yet released or moved. */
+    frames = [];
+    /** Stack of scopes: refcounted locals (with types) declared in each. */
+    scopes = [];
+    /** The function being emitted: local table (for boxedness) and whether
+     * each local arrived through the closure environment (env captures are
+     * borrowed — never declared, never released here). */
+    currentLocals = new Map();
+    captureIds = new Set();
+    /** Declared functions referenced as values: each needs an env-signature
+     * wrapper + an interned immortal closure (so `f === f` holds). */
+    fnValues = new Set();
+    /** Emitted ref-kind resolve thunks for new Promise, interned per inner
+     * typeKey → thunk symbol. */
+    resolveThunks = new Map();
+    genResThunks = new Map();
+    /** Emitted child exit adapters, interned per union id (childExitThunkFor). */
+    childExitThunks = new Map();
+    /** Emitted child-stream data adapters, interned per union id
+     * (childDataThunkFor). */
+    childDataThunks = new Map();
+    /** Emitted bound-close adapters, interned per union id
+     * (closeBindThunkFor). */
+    closeBindThunks = new Map();
+    /** Emitted close-override wrappers, interned per (union id, ret kind)
+     * (closeOverrideWrapFor). */
+    closeOverrideWraps = new Map();
+    /** Emitted dgram message adapters, interned per rinfo shape id
+     * (dgramMsgThunkFor). */
+    dgramMsgThunks = new Map();
+    /** Emitted dns.lookup callback adapters, interned per union id + param
+     * count (dnsLookupThunkFor). */
+    dnsLookupThunks = new Map();
+    /** Emitted SNI answer-closure thunks, interned per cb func-type key
+     * (sniAnswerThunkFor). */
+    sniAnswerThunks = new Map();
+    /** Emitted net.connect lookup answer thunks, interned per cb func-type
+     * key (netLookupAnswerThunkFor). */
+    netLookupAnswerThunks = new Map();
+    /** Emitted EventEmitter listener invoke adapters, interned per listener
+     * func-type key (emitterInvokeThunkFor). */
+    emitterInvokeThunks = new Map();
+    /** Emitted stream option-callback invoke adapters (read/write/final/
+     * destroy/transform/flush — the leading-`this` closures), interned per
+     * (kind, callback func-type) key (streamCbThunkFor). */
+    streamCbThunks = new Map();
+    /** Emitted stream completion-callback closure fns (the `callback` a
+     * user's write/final/destroy/transform/flush receives and calls),
+     * interned per (kind, done func-type) key (streamDoneFnFor). */
+    streamDoneFns = new Map();
+    /** Emitted CONNECT-listener union-socket adapters, interned per cb
+     * func-type key (connectSockThunkFor). */
+    connectSockThunks = new Map();
+    /** Emitted Promise.race fulfillment adapters, interned per
+     * `entryInner=>resultInner` typeKey pair (raceAdapterFor). */
+    raceThunks = new Map();
+    /** setTimeout appeared somewhere: main must run the event loop even in
+     * programs with no async functions. */
+    usesTimers = false;
+    fnByName = new Map();
+    globalsById = new Map();
+    unionsById = new Map();
+    /** Active optional-chain bind temps, by chain id (chainRecv reads). */
+    chainTemps = new Map();
+    recordsById = new Map();
+    /** Type-directed JSON walkers, interned per typeKey — one serializer per
+     * type used in jsonStringify position (sc_jw_*), one match predicate
+     * (sc_dm_*) and one checked builder (sc_dc_*) per type used in dynCheck
+     * position. Emitted as prototypes + definitions after the struct block
+     * (they reference struct types, per-shape RC helpers, and each other, so
+     * the prototypes make definition order irrelevant). */
+    jsonWriters = new Map();
+    /** The pretty-print re-indenter (type-independent, interned once):
+     * emitted on the first `JSON.stringify(v, null, space)` site. */
+    jsonIndentFn = null;
+    /** The dyn ToString pair (type-independent, interned once): emitted on
+     * the first String(unknown) / `${unknown}` site. */
+    dynToStrFn = null;
+    /** The caught→dyn converter (type-independent, interned once): emitted
+     * on the first catch binding flowing into an `unknown` slot. */
+    caughtToDynFn = null;
+    /** Interned per-union helpers: unionId → emitted function name. */
+    unionTruthyFns = new Map();
+    unionEqFns = new Map();
+    unionToStrFns = new Map();
+    unionJoinFns = new Map();
+    dynMatchers = new Map();
+    dynBuilders = new Map();
+    /** Static→DOM converters (sc_td_*), per typeKey; dynamic-keyed record
+     * read helpers (sc_rkg_*), per shapeId|result typeKey; dynamic-keyed
+     * write helpers (sc_rks_*), per shapeId. */
+    toDynFns = new Map();
+    /** The checked-dynamic function boundary's per-signature helpers (see
+     * emit-walkers.ts): call thunks (sc_dfk_*), box builders (sc_dfb_*),
+     * and dynCheck adapters (sc_dfa_*), each per func typeKey. */
+    dynFuncThunks = new Map();
+    dynFuncBoxes = new Map();
+    dynFuncAdapters = new Map();
+    /** DOM-promise settle adapters (sc_pda_*), per INNER typeKey: convert a
+     * typed fulfillment payload into the boxed destination's DOM payload
+     * (scr_dyn_new_promise_adapting's callback — toDynHelper's promise arm). */
+    promiseDynAdapters = new Map();
+    recordKeyGetFns = new Map();
+    recordKeySetFns = new Map();
+    walkerProtos = [];
+    walkerDefs = [];
+    /** Island host-call adapters, interned per (arity, void-ness): the one
+     * uniform shape scr_jsval_from_closure calls — unpack the cell array,
+     * call the closure through its real ABI (which CONSUMES its params, so
+     * each cell is retained in), return the +1 result cell or NULL for void.
+     * Definitions ride walkerDefs (self-contained over the closure ABI). */
+    islandAdapters = new Map();
+    /** TYPED island host-call adapters, interned per full signature (param
+     * typeKeys + return classification): each incoming engine argument
+     * converts to the param's static type through the exit machinery before
+     * the closure runs — see islandTypedAdapter (emit-island.ts). */
+    islandTypedAdapters = new Map();
+    /** Enclosing break/continue targets. An unlabeled `break` binds to the
+     * innermost loop-or-switch entry (labeled BLOCK entries are skipped); an
+     * unlabeled `continue` searches inward-out for the innermost LOOP,
+     * skipping switches and blocks. A LABELED jump binds to the entry whose
+     * `labels` contains its label: `break lbl` jumps to the target's
+     * endLabel (loops allocate one lazily via `usedEnd` — a C `break` only
+     * exits the innermost loop), `continue lbl` to the target loop's
+     * continueLabel. Loops: `continueLabel` is null when C `continue` is
+     * correct (unlabeled while/forOf); for/do-while loops need a goto label
+     * so `continue` still runs the update/condition, and LABELED loops of
+     * every shape allocate one up front (a labeled continue from a nested
+     * loop needs a goto). Switches are emitted as goto chains — never as C
+     * `switch` — so a C `break`/`continue` inside an emitted switch region
+     * still binds to the enclosing C loop; a break targeting the switch
+     * itself jumps to `endLabel` instead. Labeled blocks carry only an
+     * endLabel (`break lbl` is the only jump that can target them).
+     * `scopeDepth` = scopes.length at entry — a break/continue releases
+     * every scope pushed after that before jumping. `frameDepth` =
+     * frames.length at entry: statements the jump exits may still hold
+     * pending refcounted temps in their frames (a switch's discriminant,
+     * most notably), whose normal end-of-statement releases sit on the
+     * fall-through path the jump bypasses — the jump releases every frame
+     * pushed after the target's own before jumping. */
+    jumpTargets = [];
+    labelCounter = 0;
+    returnTypeByFn = new Map();
+    lineStarts = null;
+    /** May-throw analysis results (computeMayThrow): pending-exception checks
+     * are emitted only after calls that can actually raise. */
+    mayThrow;
+    indirectMayThrow;
+    /** Enclosing try contexts, innermost last — the compile-time analogue of
+     * the jump-target stack for UNWINDING: a pending check (or `throw`) inside
+     * a try releases frames/scopes down to the recorded depths and jumps to
+     * `label` (the catch, or the exception-path finally) instead of returning
+     * out of the function. Purely compile-time: entering a try emits no code. */
+    tryStack = [];
+    /** Enclosing try-with-FINALLY regions, innermost last — the pending-
+     * return analogue of tryStack: a `return` inside one snapshots its value
+     * into the function's pending-return slot (sc_pret), releases down to
+     * the region's depths, and jumps to `label` (the region's pending-return
+     * finally copy), whose tail dispatches to the next region out or emits
+     * the actual return. Spans tryBody and catchBody; the finally body
+     * itself is outside (the frontend fences jumps there). */
+    finallyStack = [];
+    /** Return type of the function being emitted — the unwind path returns a
+     * dummy of this type (never read: callers check the pending flag first). */
+    currentReturnType = VOID;
+    /** The generator channels of the function being emitted (null outside
+     * generator bodies): yieldExpr emission reads them, and emitTryCatch's
+     * catch prologue emits the GENRET sentinel re-unwind exactly here. */
+    currentGenerator = null;
+    /** Cycle-capable shapes ("object:<name>" / "record:<id>") and unions
+     * (unionId): instances get a cycle header + emitted trace/teardown, and
+     * fields/payloads of these types are visited by container traces.
+     * Computed as a greatest fixpoint in the constructor — see there. */
+    tracedShapes = new Set();
+    tracedUnions = new Set();
+    /** The class graph (single inheritance): base/children links, hierarchy
+     * membership (extends anywhere ⇒ vtable word + dynamic release), the
+     * whole-program preorder numbering behind O(1) instanceof, and the
+     * per-hierarchy virtual slot lists (root classes only). Computed once in
+     * the constructor. */
+    classMeta = new Map();
+    /** Method names with at least one may-throw implementation: a
+     * virtualCall's pending check keys on this (same over-approximation as
+     * computeMayThrow's callee cover). */
+    mayThrowMethods = new Set();
+    /** Vtable slot adapters to define after the function signatures (they
+     * call sc_f_* bodies): dedupe key "implClass.method". */
+    vtAdapters = new Map();
+    constructor(mod, sourceText) {
+        this.mod = mod;
+        for (const fn of mod.functions) {
+            this.returnTypeByFn.set(fn.name, fn.returnType);
+            this.fnByName.set(fn.name, fn);
+        }
+        const mt = computeMayThrow(mod);
+        this.mayThrow = mt.fns;
+        this.indirectMayThrow = mt.indirect;
+        for (const g of mod.globals ?? [])
+            this.globalsById.set(g.id, g);
+        for (const u of mod.unions ?? [])
+            this.unionsById.set(u.id, u);
+        for (const r of mod.records ?? [])
+            this.recordsById.set(r.id, r);
+        // The class graph. Link base/children, number the forest in preorder
+        // (roots and children in module class order — deterministic), and
+        // compute each hierarchy's virtual slots: a class's method gets a slot
+        // iff no ancestor declares it (root-most) AND some strict descendant
+        // redeclares it — never-overridden methods stay direct calls
+        // everywhere (whole-program devirtualization).
+        for (const cls of mod.classes ?? []) {
+            const meta = {
+                def: cls,
+                base: null,
+                children: [],
+                root: undefined,
+                pre: 0,
+                post: 0,
+                hierarchy: false,
+                slots: [],
+            };
+            this.classMeta.set(cls.name, meta);
+        }
+        for (const meta of this.classMeta.values()) {
+            if (meta.def.base === undefined)
+                continue;
+            const base = this.classMeta.get(meta.def.base);
+            if (!base)
+                throw new Error(`emitter bug: undeclared base class ${meta.def.base}`);
+            meta.base = base;
+            base.children.push(meta);
+        }
+        let preCounter = 0;
+        const number = (meta, root) => {
+            meta.root = root;
+            meta.pre = preCounter++;
+            for (const c of meta.children)
+                number(c, root);
+            meta.post = preCounter - 1; // max pre in the subtree (inclusive)
+        };
+        for (const meta of this.classMeta.values()) {
+            if (meta.base === null)
+                number(meta, meta);
+            // The runtime emitter class is ALWAYS a hierarchy member: ScrEmitter
+            // carries its vtable word whether or not the program subclasses it.
+            meta.hierarchy = meta.base !== null || meta.children.length > 0 ||
+                meta.def.name === RUNTIME_EMITTER_CLASS;
+        }
+        const declares = (m, method) => m.def.methods?.includes(method) ?? false;
+        const declaredBelow = (m, method) => m.children.some((c) => declares(c, method) || declaredBelow(c, method));
+        const collectSlots = (m, root, seen) => {
+            for (const method of m.def.methods ?? []) {
+                let inherited = false;
+                for (let a = m.base; a; a = a.base)
+                    inherited ||= declares(a, method);
+                if (!inherited && declaredBelow(m, method)) {
+                    let fn = this.fnByName.get(`%${m.def.name}.${method}`);
+                    if (!fn && m.def.abstractMethods?.includes(method)) {
+                        // An ABSTRACT declarer has no function; the slot's ABI
+                        // signature comes from any concrete descendant implementation
+                        // (the frontend's override exactness makes them identical).
+                        // No concrete implementation anywhere in the subtree means no
+                        // instance can dispatch the slot (only abstract classes
+                        // declare it, and abstract classes never instantiate) — skip.
+                        const findImpl = (c) => {
+                            for (const child of c.children) {
+                                const f = declares(child, method) && !child.def.abstractMethods?.includes(method)
+                                    ? this.fnByName.get(`%${child.def.name}.${method}`)
+                                    : undefined;
+                                const found = f ?? findImpl(child);
+                                if (found)
+                                    return found;
+                            }
+                            return undefined;
+                        };
+                        fn = findImpl(m);
+                        if (!fn)
+                            continue;
+                    }
+                    if (!fn)
+                        throw new Error(`emitter bug: missing method function %${m.def.name}.${method}`);
+                    // Sibling branches can each own a slot for the same method name
+                    // (each root-most in its own subtree — mixin layers make this
+                    // routine): the member name disambiguates by occurrence.
+                    const occurrence = seen.get(method) ?? 0;
+                    seen.set(method, occurrence + 1);
+                    root.slots.push({ method, declarer: m, fn, member: mangleVtSlot(method, occurrence) });
+                }
+            }
+            for (const c of m.children)
+                collectSlots(c, root, seen);
+        };
+        for (const meta of this.classMeta.values()) {
+            if (meta.base === null && meta.hierarchy)
+                collectSlots(meta, meta, new Map());
+        }
+        for (const cls of mod.classes ?? []) {
+            for (const m of cls.methods ?? []) {
+                if (this.mayThrow.has(`%${cls.name}.${m}`))
+                    this.mayThrowMethods.add(m);
+            }
+        }
+        // Cycle capability, as a greatest fixpoint over shapes and unions:
+        // start optimistic (everything cycle-capable), then repeatedly drop
+        // shapes with no cycle-capable field and unions with no cycle-capable
+        // arm until stable. Closures and promises are always cycle-capable
+        // (a captured box can hold anything; a rejection payload is an
+        // arbitrary thrown value); strings never are, and arrays/maps inherit
+        // their element/value type's capability (a record element can point
+        // back at the array holding it). The optimistic start is what keeps
+        // self- and mutually-recursive classes traced (`class A { next: A }`).
+        const shapeDefs = [
+            // The emitter class carries a synthetic closure-typed pseudo-field:
+            // its runtime registry OWNS listener closures, so the emitter
+            // hierarchy is unconditionally cycle-capable — the fixpoint must
+            // never drop it (the pseudo-field never reaches struct emission;
+            // runtime classes emit no structs).
+            ...(mod.classes ?? []).map((c) => ({
+                key: `object:${c.name}`,
+                fields: c.name === RUNTIME_EMITTER_CLASS
+                    ? [...c.fields, { name: "<listeners>", type: funcOf([], VOID) }]
+                    : c.fields,
+            })),
+            // An index-signature shape's overflow map participates like a field
+            // of map type: the shape is cycle-capable when the overflow VALUE
+            // type is (a record/object/union value in the map can point back at
+            // the record embedding it) — cycleCapable's map rule answers that.
+            ...(mod.records ?? []).map((r) => ({
+                key: `record:${r.id}`,
+                fields: r.indexValue
+                    ? [...r.fields, { name: "<overflow>", type: mapOf(STRING, r.indexValue) }]
+                    : r.fields,
+            })),
+        ];
+        for (const s of shapeDefs)
+            this.tracedShapes.add(s.key);
+        // A hierarchy is ONE unit of cycle capability: a base-typed slot can
+        // hold any subclass and retain touches the cycle header, so header
+        // presence must be uniform across an extends-hierarchy — it is
+        // cycle-capable iff ANY member is. Standalone classes and records are
+        // singleton units (today's behavior exactly).
+        const unitKeyOf = (key) => {
+            if (!key.startsWith("object:"))
+                return key;
+            const meta = this.classMeta.get(key.slice("object:".length));
+            return meta && meta.hierarchy ? `object:${meta.root.def.name}` : key;
+        };
+        const units = new Map();
+        for (const s of shapeDefs) {
+            const unit = unitKeyOf(s.key);
+            let members = units.get(unit);
+            if (!members)
+                units.set(unit, (members = []));
+            members.push(s);
+        }
+        for (const u of mod.unions ?? [])
+            this.tracedUnions.add(u.id);
+        const cycleCapable = (t) => {
+            switch (t.kind) {
+                case "func":
+                case "promise":
+                    return true;
+                case "object":
+                    return this.tracedShapes.has(`object:${t.className}`);
+                case "record":
+                    return this.tracedShapes.has(`record:${t.shapeId}`);
+                case "union":
+                    return this.tracedUnions.has(t.unionId);
+                // A map is cycle-capable exactly when its VALUE type is: a record/
+                // object/union value can hold the map that owns it, while string/
+                // array/scalar values cannot point back (array elements are fenced
+                // to kinds that cannot reach a map). Terminates: map values cannot
+                // be maps, and the record/union cases read the fixpoint sets.
+                case "map":
+                    return cycleCapable(t.value);
+                // An array is cycle-capable exactly when its ELEMENT type is —
+                // record/object/union elements (and cycle-capable inner arrays)
+                // can point back at the array. Terminates: element types are
+                // finite trees, and the record/union cases read the fixpoint sets.
+                case "array":
+                    return cycleCapable(t.elem);
+                default:
+                    return false;
+            }
+        };
+        let shrunk = true;
+        while (shrunk) {
+            shrunk = false;
+            for (const members of units.values()) {
+                if (this.tracedShapes.has(members[0].key) &&
+                    !members.some((s) => s.fields.some((f) => cycleCapable(f.type)))) {
+                    for (const s of members)
+                        this.tracedShapes.delete(s.key);
+                    shrunk = true;
+                }
+            }
+            for (const u of mod.unions ?? []) {
+                if (this.tracedUnions.has(u.id) && !u.arms.some(cycleCapable)) {
+                    this.tracedUnions.delete(u.id);
+                    shrunk = true;
+                }
+            }
+        }
+        if (sourceText !== undefined) {
+            this.lineStarts = [0];
+            for (let i = 0; i < sourceText.length; i++) {
+                if (sourceText[i] === "\n")
+                    this.lineStarts.push(i + 1);
+            }
+        }
+    }
+    emit() {
+        const body = [];
+        // Function bodies are emitted first (into this.lines) so the literal
+        // table is complete; the file is then assembled around them.
+        for (const fn of this.mod.functions) {
+            this.emitFunction(fn);
+            body.push(...this.lines);
+            this.lines.length = 0;
+        }
+        const out = [
+            `/* Generated by scriptc from ${this.mod.sourceFile}. Do not edit. */`,
+            `#include "scr_runtime.h"`,
+            `#include <math.h>`,
+            `#include <stdio.h>`,
+            `#include <stdlib.h>`,
+            ``,
+        ];
+        // Struct defs render into their own buffer BEFORE the unit-instance
+        // table flushes: class newFns point undefined-armed union fields at
+        // interned unit instances (fields start as JS's undefined, not NULL),
+        // so the instances they intern must both exist in the map by flush
+        // time and be DEFINED earlier in the file than the newFn bodies.
+        const structDefs = [];
+        this.emitStructDefs(structDefs);
+        for (const [text, sym] of this.literals) {
+            const bytes = Buffer.from(text, "utf8");
+            out.push(`static struct { size_t rc; size_t len; size_t cap; char data[${bytes.length + 1}]; } ${sym} =`, `    { SIZE_MAX, ${bytes.length}, ${bytes.length}, ${cStringLiteral(bytes)} };`);
+        }
+        if (this.literals.size > 0)
+            out.push("");
+        for (const [key, sym] of this.unitInstances) {
+            // One immortal instance per unit-armed (union, tag): tag set, payload
+            // slot and RC entry points zero — retain/release/collector all skip
+            // rc == SIZE_MAX, so these never join the RC audit or a trace walk.
+            const [unionId, tag] = key.split(":");
+            out.push(`static ScrUnion ${sym} = { .rc = SIZE_MAX, .tag = ${tag} }; /* ${unionId} unit arm */`);
+        }
+        if (this.unitInstances.size > 0)
+            out.push("");
+        out.push(...structDefs);
+        for (const [key, sym] of this.regexInstances) {
+            // One immortal ScrRegex per (pattern, flags) literal, pointing at the
+            // interned source/flags strings. `.bc` starts NULL: the runtime
+            // compiles the pattern lazily on first use and caches it here (and
+            // frees it at exit), so unexecuted regexes cost nothing. NOT const —
+            // the bc slot mutates.
+            const sep = key.indexOf("/");
+            const flags = key.slice(0, sep);
+            const pattern = key.slice(sep + 1);
+            const src = this.internLiteral(pattern);
+            const fl = this.internLiteral(flags);
+            // "*/" inside the pattern would close the trailing comment.
+            const safe = `/${pattern}/${flags}`.split("*/").join("* /");
+            out.push(`static ScrRegex ${sym} = { .rc = SIZE_MAX, .source = (ScrStr *)&${src}, ` +
+                `.flags = (ScrStr *)&${fl}, .bc = NULL }; /* ${safe} */`);
+        }
+        if (this.regexInstances.size > 0)
+            out.push("");
+        for (const [, { sym, cooked }] of this.templateStringsInstances) {
+            // One immortal ScrArr per tagged-template site: the data slots point
+            // at the interned cooked-string literals (address constants — fully
+            // static, no lazy init; reads retain immortal strings, a no-op).
+            // len == cap and nothing ever mutates it (TemplateStringsArray is
+            // ReadonlyArray, tsc rejects the mutating spellings).
+            const slots = cooked.map((s) => `(void *)&${this.internLiteral(s)}`).join(", ");
+            out.push(`static void *${sym}_data[${cooked.length}] = { ${slots} };`, `static ScrArr ${sym} = { .rc = SIZE_MAX, .len = ${cooked.length}, .cap = ${cooked.length}, ` +
+                `.elem = SCR_ELEM_STR, .elem_retain = NULL, .elem_release = NULL, .elem_trace = NULL, ` +
+                `.data = (uint64_t *)${sym}_data };`);
+        }
+        if (this.templateStringsInstances.size > 0)
+            out.push("");
+        const embedded = this.mod.embedded;
+        emitNpmEmbedding(this, out);
+        const globals = this.mod.globals ?? [];
+        for (const g of globals) {
+            // File-scope statics: zero/NULL-initialized, assigned by %init
+            // functions, released (refcounted ones) before the RC audit runs.
+            out.push(`static ${cDecl(g.type, mangleGlobal(g.id))}; /* ${g.name} */`);
+        }
+        if (globals.length > 0)
+            out.push("");
+        for (const fn of this.mod.functions)
+            out.push(this.signature(fn) + ";");
+        // Class objects (classes as values): construct-thunk prototypes plus
+        // the immortal statics that take their addresses — after the function
+        // signatures (the thunks call sc_new_*/the constructors), before
+        // anything that references &sc_co_*.
+        emitClassObjs(this, out);
+        // Vtable slot adapters: prototyped with the vtables (emitStructDefs),
+        // defined here where the method bodies they call are declared.
+        this.emitVtAdapterDefs(out);
+        // Wrappers + interned closures for declared functions used as values.
+        // Placed after the forward declarations (they call sc_f_*) and before
+        // the bodies (which reference &sc_fc_*).
+        this.emitAsyncScaffolding(out);
+        for (const name of this.fnValues) {
+            const fn = this.fnByName.get(name);
+            const params = ["ScrClosure *sc_env", ...fn.params.map((p) => cDecl(p.type, mangleLocal(p.localId)))];
+            const call = `${this.callTargetC(name)}(${fn.params.map((p) => mangleLocal(p.localId)).join(", ")})`;
+            const retType = fn.async ? "ScrPromise *" : fn.generator ? "ScrGen *" : cType(fn.returnType);
+            out.push(``, `static ${retType}${retType.endsWith("*") ? "" : " "}${mangleWrapper(name)}(${params.join(", ")}) {`, `  (void)sc_env;`, fn.returnType.kind === "void" && !fn.async && !fn.generator ? `  ${call};` : `  return ${call};`, `}`, `static struct { size_t rc; void *fn; size_t ncaps; ScrBox *props; } ${mangleFnClosure(name)} =`, `    { SIZE_MAX, (void *)&${mangleWrapper(name)}, 0, NULL };`);
+        }
+        // Construct-thunk definitions (prototyped with the class objects
+        // above): they call sc_new_* and the constructors, both declared.
+        emitCtorThunkDefs(this, out);
+        // Type-directed JSON walkers (jsonStringify serializers, dynCheck
+        // matchers/builders), interned per type during body emission above.
+        if (this.walkerProtos.length > 0) {
+            out.push("", ...this.walkerProtos, "", ...this.walkerDefs);
+        }
+        out.push("", ...body);
+        const refGlobals = globals.filter((g) => isRefCounted(g.type));
+        // Interned function-value closures are IMMORTAL (rc == SIZE_MAX), so
+        // an own-property table Object.defineProperties hung on one would
+        // outlive the RC audit — release it with the globals. Only emitted
+        // when the dispatch unit is even linked (defineProps is the only
+        // writer).
+        const fnValueProps = moduleUsesDynInvoke(this.mod) ? [...this.fnValues] : [];
+        if (refGlobals.length > 0 || fnValueProps.length > 0) {
+            out.push(`static void sc_release_globals(void) {`);
+            for (const g of refGlobals) {
+                out.push(`  ${releaseCallC(g.type, mangleGlobal(g.id))};`);
+            }
+            for (const name of fnValueProps) {
+                out.push(`  if (${mangleFnClosure(name)}.props) { scr_box_release(${mangleFnClosure(name)}.props); ${mangleFnClosure(name)}.props = NULL; }`);
+            }
+            out.push(`}`, ``);
+        }
+        const hasAsync = this.mod.functions.some((f) => f.async);
+        // Generator programs run the loop too (an empty pass when nothing is
+        // pending): its exit accounting notes still-suspended generator
+        // fibers as abandoned, so the RC audit downgrades exactly like the
+        // async loop-exhaustion story.
+        const hasGenerators = this.mod.functions.some((f) => f.generator !== undefined);
+        // Embedded npm code can leave island promise chains pending when %main
+        // returns (a package function's async work) — the loop's io hook
+        // drains the engine's job queue at quiescence, so npm-importing
+        // programs always run the loop, like Node always runs its own.
+        const usesIsland = embedded !== undefined && embedded.modules.length > 0;
+        // Exit listeners can read MODULE GLOBALS directly (test/common's
+        // runCallChecks over its mustCallChecks ledger — an interned top-level
+        // closure, no capture boxes keeping anything alive), so they must run
+        // BEFORE sc_release_globals — the atexit half alone would fire after
+        // main freed them (observed use-after-free). scr_run_exit_listeners
+        // is idempotent (scr_exit_ran), so the atexit becomes a no-op; the
+        // code argument is the hint the failure reporters maintain — exactly
+        // what the atexit path would have passed.
+        const needsRelease = refGlobals.length > 0 || fnValueProps.length > 0;
+        const runExitListeners = moduleUsesProcessEvents(this.mod) && needsRelease
+            ? "scr_run_exit_listeners((double)scr_exit_code_hint_get()); "
+            : "";
+        const releaseGlobals = needsRelease
+            ? `  ${runExitListeners}sc_release_globals();`
+            : `  /* no refcounted globals */`;
+        const uncaught = (indent) => [
+            `${indent}if (scr_exc_pending()) {`,
+            `${indent}  scr_exc_print_uncaught();`,
+            `${indent}  ${needsRelease ? `${runExitListeners}sc_release_globals(); ` : ""}return 1;`,
+            `${indent}}`,
+        ];
+        out.push(
+        // Real argc/argv feed the library's interned process.argv (see
+        // scr_lib_init — lazy, so argv-free programs allocate nothing).
+        `int main(int argc, char **argv) {`, `  scr_init();`, 
+        // The builtin error classes' preorder intervals are program-dependent
+        // (they share this module's class-forest numbering, so instanceof and
+        // the uncaught printer's Error-range test agree between runtime-made
+        // and compiled error objects) — stamp them before any code runs.
+        ...this.errorVtStampLines(), 
+        // The runtime emitter vtable's interval, when the program touches
+        // node:events (the class def rides the module exactly then).
+        ...emitterVtStampLines(this), 
+        // The runtime stream vtables' intervals, when the program touches
+        // node:stream (the emitter story — instanceof and dynamic teardown
+        // both dispatch through them).
+        ...streamVtStampLines(this), `  scr_lib_init(argc, argv);`, 
+        // Fetch-referencing programs register the native fetch bridge before any
+        // island entry (the engine's lazy boot consults it): the ONLY
+        // reference to scr_fetch.c, so fetch-free builds never compile or
+        // link it (cc.ts gates on the same predicate). moduleUsesFetch is
+        // true only for fetch-referencing embedded graphs and for USER-code
+        // fetch (the island-backed ambient's globalGet) — both boot the
+        // engine before the global is read.
+        ...(moduleUsesFetch(this.mod) ? [`  scr_fetch_install();`] : []), 
+        // Embedded graphs that import node:zlib register the island's zlib
+        // bridge before any island entry — the ONLY reference to
+        // scr_zlib_island.c (cc.ts compiles it on the same predicate), so
+        // zlib-free dynamic builds keep the island's clear refusal.
+        ...(moduleEmbedsBuiltin(this.mod, "node:zlib") ? [`  scr_zlib_island_install();`] : []), 
+        // Embedded graphs that import node:http/https register the island's
+        // http client bridge (scr_net_island.c — cc.ts compiles it and the
+        // socket units on the same predicate; native-fetch builds also
+        // register it from scr_fetch_install, idempotently).
+        ...(moduleEmbedsBuiltin(this.mod, "node:http") || moduleEmbedsBuiltin(this.mod, "node:https")
+            ? [`  scr_net_island_install();`]
+            : []), 
+        // Event-surface programs (signal/exit listeners, stdin events) fill
+        // the loop's nullable event hooks before %main — the events unit
+        // (scr_events.c) links only when this line is emitted (cc.ts gates
+        // on the same predicate, like fetch).
+        ...(moduleUsesProcessEvents(this.mod) ? [`  scr_events_install();`] : []), 
+        // Net-surface programs fill the loop's net hooks before %main — the
+        // net unit (scr_net.c) links only when this line is emitted (cc.ts
+        // gates on the same predicate, like events). The dyn-install twin
+        // stamps the netSocket handle-dispatch ops into the DOM core so
+        // sockets can cross the checked-dynamic boundary (SCR_DYN_HANDLE).
+        ...(moduleUsesNet(this.mod) ? [`  scr_net_install();`, `  scr_net_dyn_install();`] : []), 
+        // Http-surface programs additionally stamp the httpReq/httpRes
+        // handle-dispatch ops (scr_http.c links exactly when this line is
+        // emitted — cc.ts's http gate).
+        ...(moduleUsesHttpServer(this.mod) ? [`  scr_http_dyn_install();`] : []), 
+        // http2-surface programs stamp the h2 session/stream handle-dispatch
+        // ops (scr_http2.c links exactly when this line is emitted — cc.ts's
+        // http2 gate).
+        ...(moduleUsesHttp2(this.mod) ? [`  scr_http2_dyn_install();`] : []), 
+        // Stream-surface programs fill the loop's stream hook (the deferred
+        // next-tick emissions) before %main — scr_stream.c links only when
+        // this line is emitted (cc.ts gates on the same predicate).
+        ...(moduleUsesStream(this.mod) ? [`  scr_stream_install();`] : []), 
+        // Dgram/dns-surface programs fill the loop's dgram hooks the same
+        // way — scr_dgram.c links only when this line is emitted.
+        ...(moduleUsesDgram(this.mod) ? [`  scr_dgram_install();`] : []), 
+        // fs.watch programs fill the loop's watch hooks the same way —
+        // scr_watch.c links only when this line is emitted.
+        ...(moduleUsesFsWatch(this.mod) ? [`  scr_watch_install();`] : []), 
+        // The embedded npm tables must be registered before %main: the %init
+        // functions it calls import from them. Static data only — the engine
+        // still boots lazily, on the first island entry. Compressed module
+        // text (emit-island.ts stores big sources as raw DEFLATE) needs the
+        // inflater installed first — scr_zlib.c joins the link on the same
+        // moduleEmbedsCompressedNpm predicate (index.ts's zlib switch), so
+        // compression-free dynamic builds keep their exact link line.
+        ...(embedded && embedded.modules.length > 0
+            ? [
+                ...(moduleEmbedsCompressedNpm(this.mod)
+                    ? [`  scr_island_set_inflate(scr_zlib_inflate_exact);`]
+                    : []),
+                `  scr_island_modules(sc_npm_modules, ${embedded.modules.length}, ` +
+                    `${embedded.edges.length > 0 ? "sc_npm_edges" : "NULL"}, ${embedded.edges.length});`,
+            ]
+            : []), `  ${mangleFunction(this.mod.entry)}();`, 
+        // Uncaught exception from top-level code: Node exits 1.
+        ...(this.mayThrow.has(this.mod.entry) ? uncaught("  ") : []), 
+        // The event loop runs to exhaustion (microtasks before timers). A
+        // throw escaping a timer callback and unhandled promise rejections
+        // both exit 1, like Node.
+        ...(hasAsync || hasGenerators || this.usesTimers || usesIsland
+            ? [
+                `  scr_loop_run();`,
+                ...uncaught("  "),
+                `  if (scr_report_unhandled_rejections()) {`,
+                `    ${needsRelease ? `${runExitListeners}sc_release_globals(); ` : ""}return 1;`,
+                `  }`,
+            ]
+            : []), releaseGlobals, 
+        // node:test programs exit through the runner's verdict (Node's
+        // contract: 1 when any non-todo test failed). The loop-run above is
+        // guaranteed for these programs — every registration libCall sets
+        // usesTimers, so the runner fiber always drains before this line.
+        // Island programs exit with process.exitCode when the embedded
+        // graph set it (Node's implicit exit status: set it, return
+        // normally, exit with it) — 0 when never set.
+        ...(moduleUsesNodeTest(this.mod)
+            ? [`  return scr_test_exit_code();`]
+            : usesIsland
+                ? [`  return scr_island_exit_code();`]
+                : [`  return 0;`]), `}`, ``);
+        return out.join("\n");
+    }
+    emitAsyncScaffolding(out) {
+        return emitAsyncScaffolding(this, out);
+    }
+    emitStructDefs(out) {
+        return emitStructDefs(this, out);
+    }
+    /* ── vtables (class hierarchies) ──────────────────────────────────────
+     * One vtable struct type per hierarchy (named after the root): a ScrVt
+     * head — the class's preorder interval for instanceof and its DIRECT
+     * release for dynamic teardown — plus one member per virtual slot. Only
+     * methods actually overridden somewhere have slots; the slot's signature
+     * is the root-most declaring class's, and overriding implementations sit
+     * behind reinterpreting adapters (prefix layout makes the `this` cast
+     * sound). Each class gets one static const vtable instance stamped into
+     * every object it allocates. */
+    vtEntriesFor(meta) {
+        return vtEntriesFor(this, meta);
+    }
+    vtSlotParams(slot, named) {
+        return vtSlotParams(this, slot, named);
+    }
+    emitVtableDecls(out, hierarchyClasses) {
+        return emitVtableDecls(this, out, hierarchyClasses);
+    }
+    emitVtableInstances(out, hierarchyClasses) {
+        return emitVtableInstances(this, out, hierarchyClasses);
+    }
+    emitVtAdapterDefs(out) {
+        return emitVtAdapterDefs(this, out);
+    }
+    emitHierarchyClassHelpers(out, meta, s) {
+        return emitHierarchyClassHelpers(this, out, meta, s);
+    }
+    /* ── type-directed JSON walkers (jsonStringify / dynCheck) ────────────
+     * No DOM is built for stringify and no tags are consulted: the STATIC IR
+     * type drives everything, one emitted helper per typeKey (interned, like
+     * the array-HOF desugars). dynCheck helpers walk the runtime DOM (ScrDyn)
+     * against the target type: match predicates (sc_dm_*) answer "does this
+     * DOM fit?" without throwing (union arms are tried in canonical order —
+     * first FULL match wins), and builders (sc_dc_*) construct the typed
+     * value (+1) or throw a path-annotated TypeError through the exception
+     * cell. Recursion terminates because recursive shapes/unions are rejected
+     * by the frontend. */
+    dynDesc(t) {
+        return dynDesc(this, t);
+    }
+    islandAdapter(arity, retKind) {
+        return islandAdapter(this, arity, retKind);
+    }
+    islandTypedAdapter(fn) {
+        return islandTypedAdapter(this, fn);
+    }
+    unionTruthyHelper(unionId) {
+        return unionTruthyHelper(this, unionId);
+    }
+    unionEqHelper(unionId) {
+        return unionEqHelper(this, unionId);
+    }
+    unionToStrHelper(unionId) {
+        return unionToStrHelper(this, unionId);
+    }
+    unionJoinHelper(unionId) {
+        return unionJoinHelper(this, unionId);
+    }
+    jsonWriteHelper(t) {
+        return jsonWriteHelper(this, t);
+    }
+    jsonIndentHelper() {
+        return jsonIndentHelper(this);
+    }
+    dynMatchHelper(t) {
+        return dynMatchHelper(this, t);
+    }
+    dynCheckHelper(t) {
+        return dynCheckHelper(this, t);
+    }
+    toDynHelper(t) {
+        return toDynHelper(this, t);
+    }
+    dynFuncBoxHelper(t) {
+        return dynFuncBoxHelper(this, t);
+    }
+    recordKeyGetHelper(shapeId, t, overflowOnly = false) {
+        return recordKeyGetHelper(this, shapeId, t, overflowOnly);
+    }
+    recordKeySetHelper(shapeId) {
+        return recordKeySetHelper(this, shapeId);
+    }
+    dynToStrHelper() {
+        return dynToStrHelper(this);
+    }
+    caughtToDynHelper() {
+        return caughtToDynHelper(this);
+    }
+    /* ── cycle-collection wiring ──────────────────────────────────────────
+     * Containers that store a payload's RC entry points as function pointers
+     * (obj-kind boxes, union ref arms, promise payloads, the exception cell)
+     * also store the payload type's TRACE entry point — non-NULL exactly when
+     * the payload type carries a cycle header, which is what the container's
+     * own trace keys on (visit when present, release at teardown when not).
+     * Closures/unions/promises always carry one (runtime-provided traces);
+     * classes/records carry one iff their shape can participate in a cycle
+     * (emitted trace); strings/arrays/dyn never can. */
+    traceAdapterC(t) {
+        return traceAdapterC(this, t);
+    }
+    traceArgC(t) {
+        return traceArgC(this, t);
+    }
+    boxNewC(t) {
+        return boxNewC(this, t);
+    }
+    arrNewC(elem, capExpr) {
+        return arrNewC(this, elem, capExpr);
+    }
+    /* ── plumbing ─────────────────────────────────────────────────────── */
+    line(text) {
+        this.lines.push("  ".repeat(this.indent) + text);
+    }
+    srcComment(loc) {
+        if (!this.lineStarts)
+            return "";
+        let lo = 0, hi = this.lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (this.lineStarts[mid] <= loc.start)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return ` /* ${this.mod.sourceFile}:${lo + 1} */`;
+    }
+    newTemp(type, init) {
+        const name = `sc_t${this.tempCounter++}`;
+        this.line(`${cDecl(type, name)} = ${init};`);
+        if (isRefCounted(type))
+            this.currentFrame().push({ name, type });
+        return { name, type };
+    }
+    /** newTemp for a MAY-THROW runtime call: the result joins its frame
+     * BEFORE the standard pending check, so an unwind releases the dummy
+     * (NULL for refcounted kinds) harmlessly and the value is only read past
+     * the check. The shared shape of every fallible boundary call — jsOp,
+     * jsExit, composite jsMarshal, dynCheck, await reads. */
+    fallibleTemp(type, call) {
+        const t = this.newTemp(type, call);
+        this.emitPendingCheck();
+        return t;
+    }
+    currentFrame() {
+        const frame = this.frames[this.frames.length - 1];
+        if (!frame)
+            throw new Error("emitter bug: no active statement frame");
+        return frame;
+    }
+    /** Strike a refcounted temp from its frame: ownership is being moved. */
+    moveTemp(t) {
+        if (!isRefCounted(t.type))
+            return;
+        for (let i = this.frames.length - 1; i >= 0; i--) {
+            const idx = this.frames[i].findIndex((e) => e.name === t.name);
+            if (idx >= 0) {
+                this.frames[i].splice(idx, 1);
+                return;
+            }
+        }
+        throw new Error(`emitter bug: moved temp ${t.name} not found in any frame`);
+    }
+    /** The release call for one owned refcounted value. */
+    releaseValue(name, type) {
+        this.line(`${releaseCallC(type, name)};`);
+    }
+    releaseFrame(frame) {
+        for (const t of frame) {
+            if (t.boxed)
+                this.line(`scr_box_release(${t.name});`);
+            else
+                this.releaseValue(t.name, t.type);
+        }
+    }
+    /** THE release-on-jump path (break/continue/return): pending statement
+     * frames and entered scopes down to (and excluding nothing above) the
+     * given depths, innermost first — everything whose normal fall-through
+     * releases the jump bypasses. The jump target's own frame/scope stay
+     * live: a loop's releases after the loop and a switch's after its end
+     * label are still on the jump's path (return passes 0/0 — it leaves the
+     * whole function). */
+    releaseForJump(frameDepth, scopeDepth) {
+        for (let i = this.frames.length - 1; i >= frameDepth; i--)
+            this.releaseFrame(this.frames[i]);
+        for (let i = this.scopes.length - 1; i >= scopeDepth; i--)
+            this.releaseFrame(this.scopes[i]);
+    }
+    /** True when the last statement is a jump — its emission already released
+     * everything it had to, and the fall-through releases after it would be
+     * dead double-release code. `throw` counts: it unwinds (to a handler or
+     * out of the function) through the same release path. */
+    endsWithJump(stmts) {
+        const last = stmts[stmts.length - 1]?.kind;
+        return last === "return" || last === "break" || last === "continue" || last === "throw" || last === "rethrow" || last === "runtimeFence";
+    }
+    /** THE unwind path at a point where an exception is pending: release
+     * everything between here and the innermost try handler — or the whole
+     * function — via releaseForJump, then jump to the handler / return a
+     * dummy value (never read: callers of a may-throw function test the
+     * pending flag before using the result). Callers own the surrounding
+     * `if (scr_exc_pending())`; a `throw` unwinds unconditionally. */
+    emitUnwind() {
+        const target = this.tryStack[this.tryStack.length - 1];
+        if (target) {
+            this.releaseForJump(target.frameDepth, target.scopeDepth);
+            target.used = true;
+            this.line(`goto ${target.label};`);
+            return;
+        }
+        this.releaseForJump(0, 0);
+        const t = this.currentReturnType;
+        if (t.kind === "void")
+            this.line(`return;`);
+        else if (t.kind === "f64")
+            this.line(`return 0;`);
+        else if (t.kind === "bool")
+            this.line(`return false;`);
+        else
+            this.line(`return NULL;`);
+    }
+    errorVtStampLines() {
+        return errorVtStampLines(this);
+    }
+    /** The C symbol a direct call or closure enters a function through:
+     * async bodies are entered via their emitted spawn wrapper (which runs
+     * the fiber eagerly to its first suspension and returns the promise);
+     * generator bodies via theirs (which only ALLOCATES the suspended
+     * fiber and returns the generator object). */
+    callTargetC(fnName) {
+        const fn = this.fnByName.get(fnName);
+        if (fn?.async === true)
+            return mangleAsyncSpawn(fnName);
+        if (fn?.generator !== undefined)
+            return mangleGenSpawn(fnName);
+        return mangleFunction(fnName);
+    }
+    /** The emitter contract for exceptions: after EVERY call that can throw
+     * (per the may-throw analysis), test the pending flag and unwind. */
+    emitPendingCheck() {
+        this.line(`if (scr_exc_pending()) {`);
+        this.indent++;
+        this.emitUnwind();
+        this.indent--;
+        this.line(`}`);
+    }
+    internLiteral(text) {
+        let sym = this.literals.get(text);
+        if (!sym) {
+            sym = `sc_lit_${this.literals.size}`;
+            this.literals.set(text, sym);
+        }
+        return sym;
+    }
+    /** The class object's static symbol (classes as values), registering it
+     * for assembly on first use and interning the .name literal while the
+     * literal table is still open (bodies emit before the file assembles —
+     * the regex-literal discipline). */
+    classObjSym(className) {
+        let sym = this.classObjs.get(className);
+        if (!sym) {
+            const meta = this.classMeta.get(className);
+            if (!meta)
+                throw new Error(`emitter bug: classRef to unknown class ${className}`);
+            this.internLiteral(meta.def.jsName ?? "");
+            sym = mangleClassObj(className);
+            this.classObjs.set(className, sym);
+        }
+        return sym;
+    }
+    /** True when construction through a classval of `className` can throw:
+     * the runtime callee is the static class's constructor or any strict
+     * descendant's (classval flows never leave the subtree). */
+    newValueMayThrow(className) {
+        const meta = this.classMeta.get(className);
+        if (!meta)
+            throw new Error(`emitter bug: newValue on unknown class ${className}`);
+        const any = (m) => this.mayThrow.has(`%${m.def.name}.constructor`) || m.children.some(any);
+        return any(meta);
+    }
+    /** The undefined arm's tag of a union type, or -1 (not a union / no
+     * undefined arm). A record FIELD with such a type is optional-flavored:
+     * the JSON serializer DROPS it while it holds the undefined arm and the
+     * dynCheck builder produces the undefined arm for a MISSING key — both
+     * exactly Node's optional-field behavior. */
+    undefinedArmTag(t) {
+        if (t.kind !== "union")
+            return -1;
+        const def = this.unionsById.get(t.unionId);
+        return def ? def.arms.findIndex((a) => a.kind === "undefinedT") : -1;
+    }
+    /** The interned immortal instance for a UNIT arm of a union — asserts the
+     * arm really is payload-less (undefined/null). */
+    internUnitInstance(unionId, tag) {
+        const arm = this.unionsById.get(unionId)?.arms[tag];
+        if (!arm || !isUnitType(arm)) {
+            throw new Error(`emitter bug: unit instance for non-unit arm ${tag} of ${unionId}`);
+        }
+        const key = `${unionId}:${tag}`;
+        let sym = this.unitInstances.get(key);
+        if (!sym) {
+            sym = `sc_unit_${this.unitInstances.size}`;
+            this.unitInstances.set(key, sym);
+        }
+        return sym;
+    }
+    /** The C expression for that instance — the one pointer every unit-arm
+     * value of this (union, tag) is: rc == SIZE_MAX, so RC entry points and
+     * the collector both skip it and no retain is ever owed. */
+    unitInstanceRef(unionId, tag) {
+        return `(ScrUnion *)&${this.internUnitInstance(unionId, tag)}`;
+    }
+    /** The class-newFn initialization line for a field whose type ADMITS
+     * undefined — such fields start as JS's `undefined`, never the calloc
+     * NULL: tsc's strictPropertyInitialization accepts them with no
+     * initializer and no constructor assignment (undefined is in the type),
+     * so a fresh instance is readable before any assignment runs — a method
+     * assigns later, a constructor branch skips it, a base constructor's
+     * virtual call reads a derived field before super() returns. Node reads
+     * `undefined` there; a NULL payload pointer would be a segfault (union
+     * fields) or a silent nothing (jsval fields). Undefined-armed unions get
+     * the interned immortal unit instance (free; releases skip it); jsval
+     * (`any`) fields get an engine undefined cell — such classes exist only
+     * in --dynamic builds, and the field's release balances it. Empty for
+     * every type that cannot hold undefined (tsc's SPI guards those) and for
+     * record shapes' construction paths, which write every field. */
+    undefFieldInitLineC(name, t) {
+        if (t.kind === "jsval") {
+            return [`  o->${mangleField(name)} = scr_jsval_undefined(); /* ${name} starts undefined */`];
+        }
+        const tag = this.undefinedArmTag(t);
+        if (tag < 0 || t.kind !== "union")
+            return [];
+        return [`  o->${mangleField(name)} = ${this.unitInstanceRef(t.unionId, tag)}; /* ${name} starts undefined */`];
+    }
+    /* ── functions ────────────────────────────────────────────────────── */
+    signature(fn) {
+        const boxedIds = new Set(fn.locals.filter((l) => l.boxed).map((l) => l.id));
+        const parts = fn.params.map((p) => 
+        // A boxed param's sc_l_ name is its box; the raw value arrives under
+        // a sc_p_ name and is moved into the box in the prologue.
+        cDecl(p.type, boxedIds.has(p.localId) ? mangleRawParam(p.localId) : mangleLocal(p.localId)));
+        // Lifted functions receive their closure first.
+        if (fn.captures !== undefined)
+            parts.unshift("ScrClosure *sc_env");
+        const params = parts.length ? parts.join(", ") : "void";
+        return `static ${cType(fn.returnType)} ${mangleFunction(fn.name)}(${params})`;
+    }
+    emitFunction(fn) {
+        return emitFunction(this, fn);
+    }
+    /* ── statements ───────────────────────────────────────────────────── */
+    emitBlock(stmts, setup) {
+        return emitBlock(this, stmts, setup);
+    }
+    emitStmts(stmts) {
+        return emitStmts(this, stmts);
+    }
+    emitStmt(s) {
+        return emitStmt(this, s);
+    }
+    /** A fresh loop jump-target entry. `continueLabel` null means "C
+     * continue is correct" (while/forOf) — but a LABELED loop always
+     * allocates one (a labeled continue arriving from a nested loop needs a
+     * goto), and every labeled loop gets a lazy end label for labeled break
+     * (a C break only exits the innermost loop). */
+    loopTarget(continueLabel, labels) {
+        return {
+            kind: "loop",
+            continueLabel: continueLabel === null && labels !== undefined ? `sc_cont_${this.labelCounter++}` : continueLabel,
+            usedContinue: false,
+            endLabel: labels !== undefined ? `sc_end_${this.labelCounter++}` : null,
+            usedEnd: false,
+            ...(labels !== undefined && { labels }),
+            scopeDepth: this.scopes.length,
+            frameDepth: this.frames.length,
+        };
+    }
+    emitTryCatch(s) {
+        return emitTryCatch(this, s);
+    }
+    emitSwitch(s) {
+        return emitSwitch(this, s);
+    }
+    mergeBrace(emitBlockFn) {
+        return mergeBrace(this, emitBlockFn);
+    }
+    emitBranchInto(target, expr) {
+        return emitBranchInto(this, target, expr);
+    }
+    emitCondition(cond) {
+        return emitCondition(this, cond);
+    }
+    /** C expression testing JS truthiness of a temp (falsy: 0, -0, NaN, "").
+     * `x == x` rejects NaN, `x != 0` rejects both zeros; strings only need
+     * their length — no runtime call, no ownership change. */
+    truthyC(t) {
+        switch (t.type.kind) {
+            case "bool":
+                return t.name;
+            case "f64":
+                return `${t.name} == ${t.name} && ${t.name} != 0`;
+            case "string":
+                return `${t.name}->len != 0`;
+            case "jsval":
+                // Island truthiness: the engine's ToBoolean (never throws, no
+                // ownership change) — jsval operands are legal in `logical`.
+                return `(scr_jsval_truthy(${t.name}) != 0)`;
+            case "union":
+                // The ARM value's ToBoolean, answered by a per-union interned
+                // helper (switch on tag: unit arms false, scalar/string arms by
+                // value, ref arms true, jsval arms ask the engine).
+                return `${this.unionTruthyHelper(t.type.unionId)}(${t.name})`;
+            case "array":
+            case "map":
+            case "set":
+            case "regex":
+            case "url":
+            case "searchParams":
+            case "symbol":
+            case "stats":
+            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 "bytes":
+            case "func":
+            case "object":
+            case "classval":
+            case "record":
+            case "promise":
+            case "generator":
+                // JS objects are ALWAYS truthy ([] and {} included). These are
+                // non-NULL pointers, so the honest constant reads as a pointer
+                // test (no unused-value warnings, operand still evaluated).
+                return `${t.name} != NULL`;
+            case "procStream":
+                // A stream value is a JS object (always truthy); the scalar fd
+                // representation is 1 or 2, so the honest constant reads as its
+                // own non-zero test.
+                return `${t.name} != 0`;
+            case "dyn":
+                // ToBoolean over the DOM kind (scr_dyn_truthy — JS-exact for
+                // every kind; borrowed, never throws): `v || dflt` and condition
+                // descent on checked-dynamic values.
+                return `scr_dyn_truthy(${t.name})`;
+            case "undefinedT":
+            case "nullT":
+            case "caught":
+                throw new Error(`emitter bug: truthiness of ${t.type.kind}`);
+            case "void":
+                throw new Error("emitter bug: truthiness of void");
+            default: {
+                const _exhaustive = t.type;
+                void _exhaustive;
+                throw new Error("unreachable");
+            }
+        }
+    }
+    /* ── expressions ──────────────────────────────────────────────────── */
+    emitExpr(e) {
+        return emitExpr(this, e);
+    }
+    childExitThunkFor(param) {
+        return childExitThunkFor(this, param);
+    }
+    childDataThunkFor(param) {
+        return childDataThunkFor(this, param);
+    }
+    closeBindThunkFor(cbUnion, retServer) {
+        return closeBindThunkFor(this, cbUnion, retServer);
+    }
+    closeOverrideWrapFor(cbUnion, retServer) {
+        return closeOverrideWrapFor(this, cbUnion, retServer);
+    }
+    childExitThunkFor2(codeParam, sigParam) {
+        return childExitThunkFor2(this, codeParam, sigParam);
+    }
+    dgramMsgThunkFor(param) {
+        return dgramMsgThunkFor(this, param);
+    }
+    dnsLookupThunkFor(cbT) {
+        return dnsLookupThunkFor(this, cbT);
+    }
+    sniAnswerThunkFor(cbT) {
+        return sniAnswerThunkFor(this, cbT);
+    }
+    netLookupAnswerThunkFor(cbT) {
+        return netLookupAnswerThunkFor(this, cbT);
+    }
+    emitterInvokeThunkFor(cbT) {
+        return emitterInvokeThunkFor(this, cbT);
+    }
+    streamDataThunkFor(cbT) {
+        return streamDataThunkFor(this, cbT);
+    }
+    streamCbThunkFor(kind, cbT) {
+        return streamCbThunkFor(this, kind, cbT);
+    }
+    connectSockThunkFor(cbT) {
+        return connectSockThunkFor(this, cbT);
+    }
+    raceAdapterFor(from, to) {
+        return raceAdapterFor(this, from, to);
+    }
+    resolveThunkFor(inner) {
+        return resolveThunkFor(this, inner);
+    }
+}
+//# sourceMappingURL=emitter.js.map