@scriptc/compiler 0.1.1 → 0.1.3

package/dist/backend/c/exprs.js

@@ -1,5 +1,5 @@
 import { InternalCompilerError } from "../../errors.js";
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, CHILDWRITER_T, DYN, F64, islandPromisePayloadTag, isClassOwnEnumerableFieldName, isDynTypedRefType, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/ir.js";
 import { boxAccess, BYTES_NUM_KIND_C, BYTES_NUM_VAR_C, bytesElemKindC, cDecl, cFnPtrCast, cNumberLiteral, cStringLiteral, cType, DV_GET_KIND_C, DV_SET_KIND_C, elemAccess, mapKeyAccess, mapKeyKindC, mapValKindC, releaseCallC, retainCallC, vAdapters } from "./types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordClone, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./shapes.js";
@@ -20,6 +20,23 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
         defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ScrArr *sc_target = (ScrArr *)sc_p;`, `  ScrArr *sc_next = ${emitter.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`, `  size_t sc_target_len = sc_target->len;`, `  size_t sc_target_cap = sc_target->cap;`, `  uint64_t *sc_target_data = sc_target->data;`, `  uint8_t *sc_target_present = sc_target->present;`, `  ScrArrSparseSlot *sc_target_sparse = sc_target->sparse;`, `  size_t sc_target_sparse_len = sc_target->sparse_len;`, `  size_t sc_target_sparse_cap = sc_target->sparse_cap;`, `  ScrArrProp *sc_target_props = sc_target->props;`, `  size_t sc_target_prop_len = sc_target->prop_len;`, `  size_t sc_target_prop_cap = sc_target->prop_cap;`, `  sc_target->len = sc_next->len;`, `  sc_target->cap = sc_next->cap;`, `  sc_target->data = sc_next->data;`, `  sc_target->present = sc_next->present;`, `  sc_target->sparse = sc_next->sparse;`, `  sc_target->sparse_len = sc_next->sparse_len;`, `  sc_target->sparse_cap = sc_next->sparse_cap;`, `  sc_target->props = sc_next->props;`, `  sc_target->prop_len = sc_next->prop_len;`, `  sc_target->prop_cap = sc_next->prop_cap;`, `  sc_next->len = sc_target_len;`, `  sc_next->cap = sc_target_cap;`, `  sc_next->data = sc_target_data;`, `  sc_next->present = sc_target_present;`, `  sc_next->sparse = sc_target_sparse;`, `  sc_next->sparse_len = sc_target_sparse_len;`, `  sc_next->sparse_cap = sc_target_sparse_cap;`, `  sc_next->props = sc_target_props;`, `  sc_next->prop_len = sc_target_prop_len;`, `  sc_next->prop_cap = sc_target_prop_cap;`, `  scr_arr_release(sc_next);`, `}`, ``);
         return `&${commit}`;
     }
+    if (isDynTypedRefType(t)) {
+        const meta = emitter.classMeta.get(t.className);
+        if (!meta) {
+            throw new InternalCompilerError(`emitter bug: typed-ref commit of unknown class ${t.className}`);
+        }
+        const commit = `${snapshot}_commit`;
+        emitter.walkerProtos.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d); /* commit unknown class ${typeKey(t)} */`);
+        defs.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d) {`, `  ${cDecl(t, "sc_target")} = (${cType(t).trim()})sc_p;`);
+        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name))) {
+            const member = mangleField(field.name);
+            const keyLit = cStringLiteral(Buffer.from(field.name, "utf8"));
+            const keyLen = Buffer.byteLength(field.name, "utf8");
+            defs.push(`  {`, `    const ScrDyn *sc_member = scr_dyn_obj_get(sc_d, ${keyLit}, ${keyLen});`, `    ${cDecl(field.type, "sc_next")} = ${emitter.dynCheckHelper(field.type)}(sc_member ? sc_member : scr_dyn_undefined(), NULL);`, `    if (scr_exc_pending()) return;`, `    ${cDecl(field.type, "sc_old")} = sc_target->${member};`, `    sc_target->${member} = sc_next;`, ...(isRefCounted(field.type) ? [`    ${releaseCallC(field.type, "sc_old")};`] : ["    (void)sc_old;"]), `  }`);
+        }
+        defs.push(`}`, ``);
+        return `&${commit}`;
+    }
     if (t.kind !== "record")
         return "NULL";
     const shape = emitter.recordsById.get(t.shapeId);
@@ -39,6 +56,51 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     defs.push(`  ${releaseCallC(t, "sc_next")};`, `}`, ``);
     return `&${commit}`;
 }
+/** Boxes a union selected at runtime, preserving mutable/class arm identity
+ * while converting scalar and unit arms normally. It shares the enclosing
+ * adapter context so recursive class fields reuse the prototype already
+ * registered by streamTypedRefAdapter instead of recursing forever. */
+function nestedTypedRefUnionAdapter(emitter, t, ctx) {
+    const key = typeKey(t);
+    const unions = (ctx.unions ??= new Map());
+    const existing = unions.get(key);
+    if (existing)
+        return existing;
+    const def = emitter.unionsById.get(t.unionId);
+    if (!def)
+        throw new InternalCompilerError(`emitter bug: typed-ref union ${t.unionId} is undeclared`);
+    const sym = `${ctx.prefix}_union_${unions.size}`;
+    unions.set(key, sym);
+    emitter.walkerProtos.push(`static ScrDyn *${sym}(ScrUnion *sc_u); /* typed-ref union ${key} */`);
+    const lines = [`static ScrDyn *${sym}(ScrUnion *sc_u) {`, `  switch (sc_u->tag) {`];
+    def.arms.forEach((arm, tag) => {
+        if (streamTypedRefEligible(arm) || isDynTypedRefType(arm)) {
+            const adapter = streamTypedRefAdapter(emitter, arm, ctx);
+            const rc = vAdapters(arm);
+            const armKey = typeKey(arm);
+            const keyLit = cStringLiteral(Buffer.from(armKey, "utf8"));
+            lines.push(`  case ${tag}: return scr_dyn_new_typed_ref(scr_union_peek(sc_u), &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(armKey, "utf8")}, &${adapter.snapshot}, ${adapter.commit});`);
+        }
+        else if (arm.kind === "undefinedT") {
+            lines.push(`  case ${tag}: return scr_dyn_retain(scr_dyn_undefined());`);
+        }
+        else if (arm.kind === "nullT") {
+            lines.push(`  case ${tag}: return scr_dyn_new_null();`);
+        }
+        else if (arm.kind === "f64") {
+            lines.push(`  case ${tag}: return scr_dyn_new_num(scr_union_get_f64(sc_u));`);
+        }
+        else if (arm.kind === "bool") {
+            lines.push(`  case ${tag}: return scr_dyn_new_bool(scr_union_get_bool(sc_u));`);
+        }
+        else {
+            lines.push(`  case ${tag}: return ${emitter.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(sc_u));`);
+        }
+    });
+    lines.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
+    ctx.defs.push(...lines);
+    return sym;
+}
 /** Build the live dyn view of one typed stream value. Mutable reference
  * children are capsules of their own, so a write through `v.child.x` or
  * `v.items[0]` commits directly to that child's static source instead of
@@ -57,7 +119,11 @@ function streamTypedRefAdapter(emitter, t, ctx, preferredSnapshot) {
     emitter.walkerProtos.push(`static ScrDyn *${snapshot}(void *sc_p); /* materialize live stream value ${key} */`);
     adapter.commit = streamTypedRefCommitAdapter(emitter, t, snapshot, ctx.defs);
     const box = (child, expr) => {
-        if (!streamTypedRefEligible(child)) {
+        if (child.kind === "union" &&
+            (emitter.unionsById.get(child.unionId)?.arms.some((arm) => streamTypedRefEligible(arm) || isDynTypedRefType(arm)) ?? false)) {
+            return `${nestedTypedRefUnionAdapter(emitter, child, ctx)}(${expr})`;
+        }
+        if (!streamTypedRefEligible(child) && !isDynTypedRefType(child)) {
             return `${emitter.toDynHelper(child)}(${expr})`;
         }
         const nested = streamTypedRefAdapter(emitter, child, ctx);
@@ -70,7 +136,19 @@ function streamTypedRefAdapter(emitter, t, ctx, preferredSnapshot) {
         `static ScrDyn *${snapshot}(void *sc_p) { /* materialize live stream value ${key} */`,
         `  ${cDecl(t, "v")} = (${cType(t).trim()})sc_p;`,
     ];
-    if (t.kind === "record") {
+    if (isDynTypedRefType(t)) {
+        const meta = emitter.classMeta.get(t.className);
+        if (!meta) {
+            throw new InternalCompilerError(`emitter bug: typed-ref materialize of unknown class ${t.className}`);
+        }
+        lines.push(`  ScrDyn *d = scr_dyn_new_obj();`);
+        for (const field of meta.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name))) {
+            const keyLit = cStringLiteral(Buffer.from(field.name, "utf8"));
+            lines.push(`  scr_dyn_obj_set(d, ${keyLit}, ${Buffer.byteLength(field.name, "utf8")}, ${box(field.type, `v->${mangleField(field.name)}`)});`);
+        }
+        lines.push(`  return d;`);
+    }
+    else if (t.kind === "record") {
         const shape = emitter.recordsById.get(t.shapeId);
         if (!shape) {
             throw new InternalCompilerError(`emitter bug: stream typed-ref materialize of unknown shape ${t.shapeId}`);
@@ -127,12 +205,12 @@ function streamTypedRefAdapter(emitter, t, ctx, preferredSnapshot) {
 }
 /** One per-type capsule adapter for Web API arguments whose JavaScript
  * contract preserves the exact input reference. */
-function liveDynRefAdapter(emitter, t) {
+export function liveDynRefAdapter(emitter, t) {
     const key = typeKey(t);
     const existing = emitter.liveDynRefAdapters.get(key);
     if (existing)
         return existing;
-    if (!streamTypedRefEligible(t)) {
+    if (!streamTypedRefEligible(t) && !isDynTypedRefType(t)) {
         throw new InternalCompilerError(`emitter bug: live dyn ref of ${key}`);
     }
     const prefix = `sc_ldr_${emitter.liveDynRefAdapters.size}`;
@@ -157,7 +235,7 @@ function liveDynUnionRefAdapter(emitter, t) {
     }
     const mutableArms = union.arms
         .map((arm, tag) => ({ arm, tag }))
-        .filter(({ arm }) => streamTypedRefEligible(arm));
+        .filter(({ arm }) => streamTypedRefEligible(arm) || isDynTypedRefType(arm));
     if (mutableArms.length === 0) {
         throw new InternalCompilerError(`emitter bug: live dyn ref of immutable union ${key}`);
     }
@@ -179,7 +257,27 @@ function liveDynUnionRefAdapter(emitter, t) {
         const keyLit = cStringLiteral(Buffer.from(armKey, "utf8"));
         defs.push(`  case ${tag}:`, `    return scr_dyn_new_typed_ref(scr_union_peek(sc_u), &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(armKey, "utf8")}, &${adapter.snapshot}, ${adapter.commit});`);
     }
-    defs.push(`  default:`, `    return ${emitter.toDynHelper(t)}(sc_u);`, `  }`, `}`, ``);
+    const mutableTags = new Set(mutableArms.map(({ tag }) => tag));
+    union.arms.forEach((arm, tag) => {
+        if (mutableTags.has(tag))
+            return;
+        if (arm.kind === "undefinedT") {
+            defs.push(`  case ${tag}: return scr_dyn_retain(scr_dyn_undefined());`);
+        }
+        else if (arm.kind === "nullT") {
+            defs.push(`  case ${tag}: return scr_dyn_new_null();`);
+        }
+        else if (arm.kind === "f64") {
+            defs.push(`  case ${tag}: return scr_dyn_new_num(scr_union_get_f64(sc_u));`);
+        }
+        else if (arm.kind === "bool") {
+            defs.push(`  case ${tag}: return scr_dyn_new_bool(scr_union_get_bool(sc_u));`);
+        }
+        else {
+            defs.push(`  case ${tag}: return ${emitter.toDynHelper(arm)}((${cType(arm).trim()})scr_union_peek(sc_u));`);
+        }
+    });
+    defs.push(`  default: scr_trap("scriptc: internal error: invalid union tag\\n");`, `  }`, `}`, ``);
     emitter.walkerDefs.push(...defs);
     return sym;
 }
@@ -2390,7 +2488,10 @@ function emitDynamicExpr(emitter, e) {
                     : "scr_dyn_new_null()");
             }
             const v = emitter.emitExpr(e.value);
-            if (e.liveRef) {
+            const identityRef = isDynTypedRefType(v.type) ||
+                (v.type.kind === "union" &&
+                    (emitter.unionsById.get(v.type.unionId)?.arms.some(isDynTypedRefType) ?? false));
+            if (e.liveRef || identityRef) {
                 if (v.type.kind === "union") {
                     const adapter = liveDynUnionRefAdapter(emitter, v.type);
                     return emitter.newTemp(e.type, `${adapter}(${v.name})`);
@@ -3072,6 +3173,8 @@ function emitAsyncExpr(emitter, e) {
                 throw new InternalCompilerError("emitter bug: yieldExpr with no operand (frontend fills undefined)");
             const v = emitter.emitExpr(e.value);
             const yt = e.value.type;
+            if (e.awaited)
+                emitter.line(`scr_async_gen_hop_done();`);
             if (yt.kind === "f64" || yt.kind === "date") {
                 emitter.line(`scr_gen_yield_f64(${v.name});${emitter.srcComment(e.loc)}`);
             }
@@ -3105,8 +3208,9 @@ function emitAsyncExpr(emitter, e) {
             const genT = e.gen.type;
             if (genT.kind !== "generator")
                 throw new InternalCompilerError("emitter bug: genResume on a non-generator");
-            if (e.type.kind !== "record")
-                throw new InternalCompilerError("emitter bug: genResume result is not a record");
+            const resultT = genT.async ? (e.type.kind === "promise" ? e.type.inner : null) : e.type;
+            if (resultT?.kind !== "record")
+                throw new InternalCompilerError("emitter bug: genResume result is not an IteratorResult record");
             const g = emitter.emitExpr(e.gen); // borrowed for the calls below
             const sendArg = (store) => {
                 const a = emitter.emitExpr(e.arg);
@@ -3114,6 +3218,76 @@ function emitAsyncExpr(emitter, e) {
                     emitter.moveTemp(a); // the slot takes ownership
                 emitter.line(store(a));
             };
+            if (genT.async) {
+                let call;
+                if (e.mode === "next") {
+                    if (e.arg === null) {
+                        if (genT.nextT.kind === "dyn") {
+                            call = `scr_async_gen_next_ref(${g.name}, scr_dyn_retain(scr_dyn_undefined()), scr_dyn_release_v)`;
+                        }
+                        else {
+                            call = `scr_async_gen_next_none(${g.name})`;
+                        }
+                    }
+                    else {
+                        const a = emitter.emitExpr(e.arg);
+                        const t = e.arg.type;
+                        if (isRefCounted(t))
+                            emitter.moveTemp(a);
+                        call = t.kind === "f64" || t.kind === "date"
+                            ? `scr_async_gen_next_f64(${g.name}, ${a.name})`
+                            : t.kind === "bool"
+                                ? `scr_async_gen_next_bool(${g.name}, ${a.name})`
+                                : `scr_async_gen_next_ref(${g.name}, ${a.name}, ${vAdapters(t).release})`;
+                    }
+                }
+                else if (e.mode === "return") {
+                    if (e.arg === null) {
+                        call = `scr_async_gen_return_none(${g.name})`;
+                    }
+                    else {
+                        const a = emitter.emitExpr(e.arg);
+                        const t = e.arg.type;
+                        if (isRefCounted(t))
+                            emitter.moveTemp(a);
+                        call = t.kind === "f64" || t.kind === "date"
+                            ? `scr_async_gen_return_f64(${g.name}, ${a.name})`
+                            : t.kind === "bool"
+                                ? `scr_async_gen_return_bool(${g.name}, ${a.name})`
+                                : `scr_async_gen_return_ref(${g.name}, ${a.name}, ${vAdapters(t).release})`;
+                    }
+                }
+                else {
+                    if (e.arg === null)
+                        throw new InternalCompilerError("emitter bug: async genResume throw with no payload");
+                    const a = emitter.emitExpr(e.arg);
+                    const t = e.arg.type;
+                    if (isRefCounted(t))
+                        emitter.moveTemp(a);
+                    if (t.kind === "date") {
+                        throw new InternalCompilerError("emitter bug: Date async-generator throw reached backend");
+                    }
+                    else if (t.kind === "f64") {
+                        emitter.line(`scr_throw_f64(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "bool") {
+                        emitter.line(`scr_throw_bool(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "string") {
+                        emitter.line(`scr_throw_str(${a.name});${emitter.srcComment(e.loc)}`);
+                    }
+                    else if (t.kind === "object" && emitter.classMeta.get(t.className)?.hierarchy) {
+                        const rc = vAdapters(t);
+                        emitter.line(`scr_throw_obj(${a.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(e.loc)}`);
+                    }
+                    else {
+                        const rc = vAdapters(t);
+                        emitter.line(`scr_throw_ref(${a.name}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(t)});${emitter.srcComment(e.loc)}`);
+                    }
+                    call = `scr_async_gen_throw(${g.name})`;
+                }
+                return emitter.newTemp(e.type, call);
+            }
             if (e.mode === "next") {
                 if (e.arg === null) {
                     // Valueless resume: dyn channels read JS's undefined; unit
@@ -3178,7 +3352,7 @@ function emitAsyncExpr(emitter, e) {
                 }
                 emitter.line(`scr_gen_resume_throw(${g.name});`);
             }
-            const helper = genResultThunkFor(emitter, genT, e.type);
+            const helper = genResultThunkFor(emitter, genT, resultT);
             // The record builds before the check so an unwind (a propagated
             // body exception) releases it as the frame's never-read dummy.
             return emitter.fallibleTemp(e.type, `${helper}(${g.name})`);
@@ -4590,6 +4764,62 @@ function emitPrimitiveLibCall(state) {
             return finish(`scr_sym_for(${arg(0)})`);
         case "sym.toString":
             return finish(`scr_sym_to_string(${arg(0)})`);
+        case "bigint.parse":
+            return finish(`scr_bigint_parse(${arg(0)})`);
+        case "bigint.fromF64":
+            return finish(`scr_bigint_from_f64(${arg(0)})`);
+        case "bigint.neg":
+            return finish(`scr_bigint_neg(${arg(0)})`);
+        case "bigint.not":
+            return finish(`scr_bigint_not(${arg(0)})`);
+        case "bigint.add":
+            return finish(`scr_bigint_add(${arg(0)}, ${arg(1)})`);
+        case "bigint.sub":
+            return finish(`scr_bigint_sub(${arg(0)}, ${arg(1)})`);
+        case "bigint.mul":
+            return finish(`scr_bigint_mul(${arg(0)}, ${arg(1)})`);
+        case "bigint.div":
+            return finish(`scr_bigint_div(${arg(0)}, ${arg(1)})`);
+        case "bigint.mod":
+            return finish(`scr_bigint_mod(${arg(0)}, ${arg(1)})`);
+        case "bigint.pow":
+            return finish(`scr_bigint_pow(${arg(0)}, ${arg(1)})`);
+        case "bigint.and":
+            return finish(`scr_bigint_and(${arg(0)}, ${arg(1)})`);
+        case "bigint.or":
+            return finish(`scr_bigint_or(${arg(0)}, ${arg(1)})`);
+        case "bigint.xor":
+            return finish(`scr_bigint_xor(${arg(0)}, ${arg(1)})`);
+        case "bigint.shl":
+            return finish(`scr_bigint_shl(${arg(0)}, ${arg(1)})`);
+        case "bigint.shr":
+            return finish(`scr_bigint_shr(${arg(0)}, ${arg(1)})`);
+        case "bigint.eq":
+            return finish(`scr_bigint_eq(${arg(0)}, ${arg(1)})`);
+        case "bigint.cmp":
+            return finish(`scr_bigint_cmp_f64(${arg(0)}, ${arg(1)})`);
+        case "bigint.cmpNumber":
+            return finish(`scr_bigint_cmp_number(${arg(0)}, ${arg(1)})`);
+        case "bigint.truthy":
+            return finish(`scr_bigint_truthy(${arg(0)})`);
+        case "bigint.toString":
+            return finish(`scr_bigint_to_string(${arg(0)}, ${arg(1)})`);
+        case "bigint.inspect":
+            return finish(`scr_bigint_inspect(${arg(0)})`);
+        case "bigint.toF64":
+            return finish(`scr_bigint_to_f64(${arg(0)})`);
+        case "bigint.asUintN":
+            return finish(`scr_bigint_as_uint_n(${arg(0)}, ${arg(1)})`);
+        case "bigint.asIntN":
+            return finish(`scr_bigint_as_int_n(${arg(0)}, ${arg(1)})`);
+        case "bigint.bufferRead":
+            return finish(`scr_bigint_buffer_read(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+        case "bigint.bufferWrite":
+            return finish(`scr_bigint_buffer_write(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
+        case "bigint.dataViewGet":
+            return finish(`scr_bigint_dataview_get(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+        case "bigint.dataViewSet":
+            return finish(`scr_bigint_dataview_set(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
         case "sym.desc":
         case "sym.keyFor": {
             // `string | undefined` — the child.stdout pattern with a
@@ -4719,7 +4949,7 @@ function emitUtilLibCall(state) {
     }
 }
 function emitCryptoBytesLibCall(state) {
-    const { e, arg, finish } = state;
+    const { e, emitter, args, arg, finish } = state;
     const fn = e.fn;
     switch (fn) {
         case "crypto.x509Fingerprint":
@@ -4754,6 +4984,56 @@ function emitCryptoBytesLibCall(state) {
             return finish(`scr_crypto_hash_digest_str(${arg(0)}, ${arg(1)}, ${arg(2)})`);
         case "crypto.hashDigestBytes":
             return finish(`scr_crypto_hash_digest_bytes(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "crypto.hashNew":
+            return finish(`scr_crypto_hash_new(${arg(0)})`);
+        case "crypto.hmacNewStr":
+            return finish(`scr_crypto_hmac_new_str(${arg(0)}, ${arg(1)})`);
+        case "crypto.hmacNewBytes":
+            return finish(`scr_crypto_hmac_new_bytes(${arg(0)}, ${arg(1)})`);
+        case "crypto.hashUpdateStr":
+        case "crypto.hmacUpdateStr":
+            return finish(`scr_crypto_hash_update_str(${arg(0)}, ${arg(1)})`);
+        case "crypto.hashUpdateBytes":
+        case "crypto.hmacUpdateBytes":
+            return finish(`scr_crypto_hash_update_bytes(${arg(0)}, ${arg(1)})`);
+        case "crypto.hashCopy":
+            return finish(`scr_crypto_hash_copy(${arg(0)})`);
+        case "crypto.hashDigestString":
+        case "crypto.hmacDigestString":
+            return finish(`scr_crypto_hash_digest_string(${arg(0)}, ${arg(1)})`);
+        case "crypto.hashDigestBuffer":
+        case "crypto.hmacDigestBuffer":
+            return finish(`scr_crypto_hash_digest_buffer(${arg(0)})`);
+        case "crypto.timingSafeEqual":
+            return finish(`scr_crypto_timing_safe_equal(${arg(0)}, ${arg(1)})`);
+        case "crypto.randomFill":
+            return finish(`scr_crypto_random_fill(${arg(0)}, ${arg(1)}, ${arg(2)})`);
+        case "crypto.randomFillRest":
+            return finish(`scr_crypto_random_fill_rest(${arg(0)}, ${arg(1)})`);
+        case "crypto.randomInt":
+            return finish(`scr_crypto_random_int(${arg(0)}, ${arg(1)})`);
+        case "crypto.pbkdf2":
+            return finish(`scr_crypto_pbkdf2(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
+        case "crypto.randomBytesCb":
+        case "crypto.pbkdf2Cb": {
+            emitter.usesTimers = true;
+            const cbIndex = fn === "crypto.randomBytesCb" ? 1 : 5;
+            const cbT = e.args[cbIndex].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: crypto callback not a func");
+            const callback = args[cbIndex];
+            emitter.moveTemp(callback);
+            const adapter = emitter.cryptoBytesThunkFor(cbT);
+            if (fn === "crypto.randomBytesCb") {
+                emitter.line(`scr_crypto_random_bytes_async(${arg(0)}, ${callback.name}, &${adapter});${emitter.srcComment(e.loc)}`);
+            }
+            else {
+                emitter.line(`scr_crypto_pbkdf2_async(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${callback.name}, &${adapter});${emitter.srcComment(e.loc)}`);
+            }
+            if (MAY_THROW_LIB_FNS.has(fn))
+                emitter.emitPendingCheck();
+            return { name: "", type: e.type };
+        }
         // The Buffer statics (scr_bytes.c): fromStr decodes Node-
         // leniently (never throws), concat copies its borrowed list.
         case "buffer.fromStr":
@@ -4892,26 +5172,59 @@ function emitChildProcessLibCall(state) {
             const absent = emitter.unitInstanceRef(e.type.unionId, unitTag);
             return emitter.newTemp(e.type, `${has}(${arg(0)}) ? ${present} : ${absent}`);
         }
+        case "child.stdin":
         case "child.stdout":
         case "child.stderr": {
-            // `Readable | null` — the child.pid pattern with a REF arm:
-            // the runtime answers a +1 stream handle or NULL (not piped).
+            // `Writable | null` / `Readable | null` — the child.pid
+            // pattern with a REF arm: the runtime answers a +1 stream
+            // handle or NULL (not piped).
             if (e.type.kind !== "union") {
                 throw new InternalCompilerError(`emitter bug: ${e.fn} result is not a union`);
             }
             const def = emitter.unionsById.get(e.type.unionId);
-            const streamTag = def ? def.arms.findIndex((a) => a.kind === "childStream") : -1;
+            const writer = e.fn === "child.stdin";
+            const streamTag = def ? def.arms.findIndex((a) => a.kind === (writer ? "childWriter" : "childStream")) : -1;
             const nullTag = def ? def.arms.findIndex((a) => a.kind === "nullT") : -1;
             if (streamTag < 0 || nullTag < 0) {
                 throw new InternalCompilerError(`emitter bug: ${e.fn} union lacks its arms`);
             }
-            const get = e.fn === "child.stdout" ? "scr_child_stdout" : "scr_child_stderr";
-            const raw = emitter.newTemp(CHILDSTREAM_T, `${get}(${arg(0)})`);
+            const get = writer ? "scr_child_stdin" : e.fn === "child.stdout" ? "scr_child_stdout" : "scr_child_stderr";
+            const rawType = writer ? CHILDWRITER_T : CHILDSTREAM_T;
+            const raw = emitter.newTemp(rawType, `${get}(${arg(0)})`);
             emitter.moveTemp(raw); // ownership passes into the union arm below
-            const present = `scr_union_new_ref(${streamTag}, ${raw.name}, &scr_child_stream_retain_v, &scr_child_stream_release_v, NULL)`;
+            const stem = writer ? "scr_child_writer" : "scr_child_stream";
+            const present = `scr_union_new_ref(${streamTag}, ${raw.name}, &${stem}_retain_v, &${stem}_release_v, NULL)`;
             const absent = emitter.unitInstanceRef(e.type.unionId, nullTag);
             return emitter.newTemp(e.type, `${raw.name} != NULL ? ${present} : ${absent}`);
         }
+        case "writer.writeString":
+            return finish(`scr_child_writer_write_string(${arg(0)}, ${arg(1)})`);
+        case "writer.writeBytes":
+            return finish(`scr_child_writer_write_bytes(${arg(0)}, ${arg(1)})`);
+        case "writer.end":
+            return finish(`scr_child_writer_end(${arg(0)})`);
+        case "writer.destroy":
+            return finish(`scr_child_writer_destroy(${arg(0)})`);
+        case "writer.writable":
+            return finish(`scr_child_writer_writable(${arg(0)})`);
+        case "writer.onDrain":
+        case "writer.onFinish": {
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            const fnName = fn === "writer.onDrain" ? "scr_child_writer_on_drain" : "scr_child_writer_on_finish";
+            emitter.line(`${fnName}(${arg(0)}, ${cb.name}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
+        case "writer.onError": {
+            const cbT = e.args[1].type;
+            if (cbT.kind !== "func")
+                throw new InternalCompilerError("emitter bug: writer.onError callback not a func");
+            const cb = args[1];
+            emitter.moveTemp(cb);
+            const adapter = cbT.params.length === 0 ? "scr_child_err_thunk0" : "scr_child_err_thunk_error";
+            emitter.line(`scr_child_writer_on_error(${arg(0)}, ${cb.name}, &${adapter}, ${arg(2)});${emitter.srcComment(e.loc)}`);
+            return { name: "", type: e.type };
+        }
         case "procStream.write":
             // The receiver IS the fd scalar; dispatches onto the exact
             // promptly-submitted stdout/stderr paths (ordering identical).
@@ -6747,6 +7060,38 @@ function emitProcessLibCall(state) {
             return finish(`scr_process_getuid()`);
         case "process.uptime":
             return finish(`scr_process_uptime()`);
+        case "module.registryInit":
+            return finish(`scr_module_registry_init(${arg(0)})`);
+        case "module.define":
+            return finish(`scr_module_define(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
+        case "module.enter":
+            return finish(`scr_module_enter(${arg(0)})`);
+        case "module.link":
+            return finish(`scr_module_link(${arg(0)}, ${arg(1)})`);
+        case "module.finish":
+            return finish(`scr_module_finish(${arg(0)})`);
+        case "module.fail":
+            return finish(`scr_module_fail(${arg(0)})`);
+        case "module.filename":
+            return finish(`scr_module_filename(${arg(0)})`);
+        case "module.id":
+            return finish(`scr_module_id(${arg(0)})`);
+        case "module.path":
+            return finish(`scr_module_path(${arg(0)})`);
+        case "module.paths":
+            return finish(`scr_module_paths(${arg(0)})`);
+        case "module.children":
+            return finish(`scr_module_children(${arg(0)})`);
+        case "module.parent":
+            return finish(`scr_module_parent(${arg(0)})`);
+        case "module.loaded":
+            return finish(`scr_module_loaded(${arg(0)})`);
+        case "module.cacheGet":
+            return finish(`scr_module_cache_get(${arg(0)})`);
+        case "module.cacheHas":
+            return finish(`scr_module_cache_has(${arg(0)})`);
+        case "module.cacheKeys":
+            return finish(`scr_module_cache_keys()`);
         case "process.availableMemory":
             return finish(`scr_available_memory()`);
         case "process.constrainedMemory":
@@ -7492,6 +7837,9 @@ function emitStreamLibCall(state) {
         case "stream.destroyErr":
             emitter.usesTimers = true;
             return finish(`(${cType(e.type).trim()})scr_stream_destroy((ScrStream *)${arg(0)}, ${arg(1)})`);
+        case "stream.iteratorClose":
+            emitter.usesTimers = true;
+            return finish(`(${cType(e.type).trim()})scr_stream_iterator_close((ScrStream *)${arg(0)})`);
         case "stream.prop": {
             // The property NAME is a compile-time literal; args[1]'s
             // emitted temp is unused (released with the statement's frame).
@@ -7533,6 +7881,8 @@ function emitAssertInspectLibCall(state) {
             return finish(`scr_assert_ok(${arg(0)}, ${arg(1)})`);
         case "assert.eqF64":
             return finish(`scr_assert_eq_f64(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
+        case "assert.eqBigInt":
+            return finish(`scr_assert_eq_bigint(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
         case "assert.eqStr":
             return finish(`scr_assert_eq_str(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)})`);
         case "assert.eqBool":
@@ -7751,6 +8101,7 @@ function emitLibCallExpr(emitter, e) {
         case "regexp":
         case "intl":
         case "sym":
+        case "bigint":
         case "perf":
         case "number":
         case "date":
@@ -7767,6 +8118,7 @@ function emitLibCallExpr(emitter, e) {
         case "cp":
         case "spawnRes":
         case "child":
+        case "writer":
         case "procStream":
             return emitChildProcessLibCall(state);
         case "net":
@@ -7791,6 +8143,7 @@ function emitLibCallExpr(emitter, e) {
             return emitAsyncContextLibCall(state);
         case "process":
         case "stdin":
+        case "module":
             return emitProcessLibCall(state);
         case "error":
         case "regex":