@scriptc/compiler 0.0.36 → 0.1.2

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, 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";
@@ -17,7 +17,24 @@ function streamTypedRefCommitAdapter(emitter, t, snapshot, defs) {
     if (t.kind === "array") {
         const commit = `${snapshot}_commit`;
         emitter.walkerProtos.push(`static void ${commit}(void *sc_p, const ScrDyn *sc_d); /* commit live stream element ${typeKey(t)} */`);
-        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;`, `  sc_target->len = sc_next->len;`, `  sc_target->cap = sc_next->cap;`, `  sc_target->data = sc_next->data;`, `  sc_next->len = sc_target_len;`, `  sc_next->cap = sc_target_cap;`, `  sc_next->data = sc_target_data;`, `  scr_arr_release(sc_next);`, `}`, ``);
+        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")
@@ -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}`);
@@ -132,7 +210,7 @@ function liveDynRefAdapter(emitter, 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;
 }
@@ -1284,12 +1382,7 @@ function emitContainerExpr(emitter, e) {
             e.elems.forEach((el, i) => {
                 const v = emitter.emitExpr(el);
                 if (spreadSet.has(i)) {
-                    const n = `sc_i${emitter.tempCounter++}`;
-                    emitter.line(`for (size_t ${n} = 0, ${n}_len = (size_t)scr_arr_len(${v.name}); ${n} < ${n}_len; ${n}++) {`);
-                    emitter.indent++;
-                    emitter.line(`scr_arr_push_${acc}(${arr.name}, scr_arr_get_${acc}(${v.name}, (double)${n}));`);
-                    emitter.indent--;
-                    emitter.line(`}`);
+                    emitter.line(`scr_arr_push_spread(${arr.name}, ${v.name});`);
                     return;
                 }
                 if (acc === "ref")
@@ -1335,6 +1428,20 @@ function emitContainerExpr(emitter, e) {
             const acc = elemAccess(e.arr.type.elem);
             return emitter.newTemp(e.type, `scr_arr_get_${acc}(${arr.name}, ${idx.name})`);
         }
+        case "arrayHas": {
+            const arr = emitter.emitExpr(e.arr);
+            const idx = emitter.emitExpr(e.index);
+            if (e.arr.type.kind !== "array")
+                throw new InternalCompilerError("emitter bug: arrayHas on non-array");
+            return emitter.newTemp(e.type, `scr_arr_has(${arr.name}, ${idx.name})`);
+        }
+        case "arrayState": {
+            const arr = emitter.emitExpr(e.arr);
+            const idx = emitter.emitExpr(e.index);
+            if (e.arr.type.kind !== "array")
+                throw new InternalCompilerError("emitter bug: arrayState on non-array");
+            return emitter.newTemp(e.type, `scr_arr_state(${arr.name}, ${idx.name})`);
+        }
         case "arrIntrinsic": {
             const r = emitter.emitExpr(e.receiver);
             if (e.receiver.type.kind !== "array")
@@ -1344,6 +1451,10 @@ function emitContainerExpr(emitter, e) {
             switch (method) {
                 case "length":
                     return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                case "nextPresent": {
+                    const start = emitter.emitExpr(e.args[0]);
+                    return emitter.newTemp(e.type, `scr_arr_next_present(${r.name}, ${start.name})`);
+                }
                 case "push": {
                     // Variadic like JS: every argument evaluates first (left to
                     // right — an argument reading the array sees the pre-push
@@ -1363,18 +1474,15 @@ function emitContainerExpr(emitter, e) {
                         : emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
                 }
                 case "pushSpread": {
-                    // `a.push(...src)`: append src's elements in order. The source
-                    // is BORROWED; the count snapshots before the loop so
-                    // `a.push(...a)` duplicates exactly like JS. _get_ref's +1
-                    // moves into _push_ref — RC-balanced. Result: the new length.
+                    // `a.push(...src)`: append src's indexed state in order while
+                    // preserving holes; the runtime snapshots self-spread and
+                    // retains copied refs. Result: the new length.
                     const src = emitter.emitExpr(e.args[0]);
-                    const n = `sc_i${emitter.tempCounter++}`;
-                    emitter.line(`for (size_t ${n} = 0, ${n}_len = (size_t)scr_arr_len(${src.name}); ${n} < ${n}_len; ${n}++) {`);
-                    emitter.indent++;
-                    emitter.line(`scr_arr_push_${acc}(${r.name}, scr_arr_get_${acc}(${src.name}, (double)${n}));`);
-                    emitter.indent--;
-                    emitter.line(`}`);
-                    return emitter.newTemp(e.type, `scr_arr_len(${r.name})`);
+                    return emitter.newTemp(e.type, `scr_arr_push_spread(${r.name}, ${src.name})`);
+                }
+                case "concatSpread": {
+                    const src = emitter.emitExpr(e.args[0]);
+                    return emitter.newTemp(e.type, `scr_arr_concat_copy(${r.name}, ${src.name})`);
                 }
                 case "unshift": {
                     // Like push, every argument evaluates before mutation. Apply
@@ -1396,9 +1504,39 @@ function emitContainerExpr(emitter, e) {
                     return emitter.newTemp(e.type, `scr_arr_unshift_spread(${r.name}, ${src.name})`);
                 }
                 case "pop":
-                    // Ownership of a refcounted element moves OUT of the array to
-                    // this temp (+1 to us, the runtime does not release it).
-                    return emitter.newTemp(e.type, `scr_arr_pop_${acc}(${r.name})`);
+                case "shift": {
+                    // Move the slot once, preserving undefined and holes as values
+                    // while still applying the method's length/index mutation.
+                    if (e.type.kind !== "union")
+                        throw new InternalCompilerError("emitter bug: array removal result is not a union");
+                    const elemT = e.receiver.type.elem;
+                    const def = emitter.unionsById.get(e.type.unionId);
+                    const tag = def ? def.arms.findIndex((arm) => typeEquals(arm, elemT)) : -1;
+                    const undefTag = undefinedArmTag(e.type, emitter.unionsById);
+                    const sameUnion = elemT.kind === "union" && typeEquals(elemT, e.type);
+                    if ((!sameUnion && tag < 0) || undefTag < 0)
+                        throw new InternalCompilerError("emitter bug: array removal union lacks its arms");
+                    const state = `sc_remove_state${emitter.tempCounter++}`;
+                    const slot = `sc_remove_slot${emitter.tempCounter++}`;
+                    emitter.line(`uint64_t ${slot} = 0;`);
+                    emitter.line(`uint8_t ${state} = scr_arr_${method}_state(${r.name}, &${slot});`);
+                    let present;
+                    if (elemT.kind === "f64") {
+                        const number = `sc_remove_number${emitter.tempCounter++}`;
+                        emitter.line(`double ${number}; memcpy(&${number}, &${slot}, sizeof ${number});`);
+                        present = `scr_union_new_f64(${tag}, ${number})`;
+                    }
+                    else if (elemT.kind === "bool") {
+                        present = `scr_union_new_bool(${tag}, ${slot} != 0)`;
+                    }
+                    else {
+                        const ref = `sc_remove_ref${emitter.tempCounter++}`;
+                        emitter.line(`void *${ref}; memcpy(&${ref}, &${slot}, sizeof ${ref});`);
+                        const rc = vAdapters(elemT);
+                        present = sameUnion ? `(ScrUnion *)${ref}` : `scr_union_new_ref(${tag}, ${ref}, &${rc.retain}, &${rc.release}, ${emitter.traceArgC(elemT)})`;
+                    }
+                    return emitter.newTemp(e.type, `${state} == SCR_ARR_VALUE ? ${present} : ${emitter.unitInstanceRef(e.type.unionId, undefTag)}`);
+                }
                 case "indexOf": {
                     // The needle is BORROWED (released with this statement's frame);
                     // the ref variant dispatches on the array's element kind
@@ -1448,6 +1586,12 @@ function emitContainerExpr(emitter, e) {
                     emitter.emitPendingCheck();
                     return out;
                 }
+                case "withUndefined": {
+                    const index = emitter.emitExpr(e.args[0]);
+                    const out = emitter.newTemp(e.type, `scr_arr_with_undefined(${r.name}, ${index.name})`);
+                    emitter.emitPendingCheck();
+                    return out;
+                }
                 case "splice": {
                     // The removal splice: the removed elements come back as a
                     // fresh +1 array, their ownership MOVED out of the receiver
@@ -1457,30 +1601,6 @@ function emitContainerExpr(emitter, e) {
                     const cnt = e.args[1] ? emitter.emitExpr(e.args[1]).name : "INFINITY";
                     return emitter.newTemp(e.type, `scr_arr_splice(${r.name}, ${start.name}, ${cnt})`);
                 }
-                case "shift": {
-                    // JS shift: undefined on an empty array, else the first
-                    // element out (ref ownership moves into the union box) with
-                    // the tail sliding down. Union construction is type-directed
-                    // here, the envGet convention.
-                    if (e.type.kind !== "union")
-                        throw new InternalCompilerError("emitter bug: shift result is not a union");
-                    const elemT = e.receiver.type.elem;
-                    const def = emitter.unionsById.get(e.type.unionId);
-                    const tag = def ? def.arms.findIndex((a) => typeEquals(a, elemT)) : -1;
-                    const undefTag = undefinedArmTag(e.type, emitter.unionsById);
-                    if (tag < 0 || undefTag < 0)
-                        throw new InternalCompilerError("emitter bug: shift union lacks its arms");
-                    const absent = emitter.unitInstanceRef(e.type.unionId, undefTag);
-                    const present = elemT.kind === "f64"
-                        ? `scr_union_new_f64(${tag}, scr_arr_shift_f64(${r.name}))`
-                        : elemT.kind === "bool"
-                            ? `scr_union_new_bool(${tag}, scr_arr_shift_bool(${r.name}))`
-                            : (() => {
-                                const rc = vAdapters(elemT);
-                                return `scr_union_new_ref(${tag}, scr_arr_shift_ref(${r.name}), &${rc.retain}, &${rc.release}, ${emitter.traceArgC(elemT)})`;
-                            })();
-                    return emitter.newTemp(e.type, `scr_arr_len(${r.name}) ? ${present} : ${absent}`);
-                }
                 default: {
                     const _exhaustive = method;
                     void _exhaustive;
@@ -2368,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})`);
@@ -3050,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)}`);
             }
@@ -3083,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);
@@ -3092,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
@@ -3156,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})`);
@@ -6725,6 +6921,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":
@@ -7470,6 +7698,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).
@@ -7769,6 +8000,7 @@ function emitLibCallExpr(emitter, e) {
             return emitAsyncContextLibCall(state);
         case "process":
         case "stdin":
+        case "module":
             return emitProcessLibCall(state);
         case "error":
         case "regex":
@@ -7832,6 +8064,8 @@ export function emitExpr(emitter, e) {
         case "arrayLit":
         case "arrayNewLen":
         case "arrayGet":
+        case "arrayHas":
+        case "arrayState":
         case "arrIntrinsic":
         case "bytesNew":
         case "bytesIntrinsic":