@scriptc/compiler 0.0.21 → 0.0.23

package/dist/backend/emission/emit-exprs.js

@@ -1,9 +1,345 @@
-import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals } from "../../ir/nodes.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, retainCallC, vAdapters } from "./emit-types.js";
+import { arrayOf, BOOL, BYTES_U8, bytesOf, canMarshalFuncIntoIsland, CHILDSTREAM_T, DYN, F64, islandPromisePayloadTag, isRefCounted, isUnitType, MAY_THROW_LIB_FNS, RUNTIME_ERROR_CLASSES, STRING, typeEquals, typeKey } from "../../ir/nodes.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 "./emit-types.js";
 import { mangleClassNew, mangleClassRetain, mangleClassStruct, mangleField, mangleFnClosure, mangleFunction, mangleGlobal, mangleLocal, mangleRecordNew, mangleRecordStruct, mangleVtStruct } from "../mangle.js";
 import { OVERFLOW_MEMBER } from "./emit-shapes.js";
 import { dynDestrCheckHelper, dynIterNHelper, dynKeyGetHelper } from "./emit-walkers.js";
 import { genResultThunkFor } from "./emit-async.js";
+function streamTypedRefCommitAdapter(E, t, snapshot, defs) {
+    if (t.kind === "bytes") {
+        const commit = `${snapshot}_commit`;
+        E.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) {`, `  ScrBytes *sc_target = (ScrBytes *)sc_p;`, `  ScrBytes *sc_next = ${E.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`, `  scr_bytes_copy_contents(sc_target, sc_next);`, `  scr_bytes_release(sc_next);`, `}`, ``);
+        return `&${commit}`;
+    }
+    if (t.kind === "array") {
+        const commit = `${snapshot}_commit`;
+        E.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 = ${E.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);`, `}`, ``);
+        return `&${commit}`;
+    }
+    if (t.kind !== "record")
+        return "NULL";
+    const shape = E.recordsById.get(t.shapeId);
+    if (!shape) {
+        throw new Error(`emitter bug: stream typed-ref commit of unknown shape ${t.shapeId}`);
+    }
+    const commit = `${snapshot}_commit`;
+    E.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) {`, `  ${cDecl(t, "sc_target")} = (${cType(t).trim()})sc_p;`, `  ${cDecl(t, "sc_next")} = ${E.dynCheckHelper(t)}(sc_d, NULL);`, `  if (!sc_next) return;`);
+    for (const field of shape.fields) {
+        const member = mangleField(field.name);
+        defs.push(`  {`, `    ${cDecl(field.type, "sc_old")} = sc_target->${member};`, `    sc_target->${member} = sc_next->${member};`, `    sc_next->${member} = sc_old;`, `  }`);
+    }
+    if (shape.indexValue) {
+        defs.push(`  {`, `    ScrMap *sc_old = sc_target->${OVERFLOW_MEMBER};`, `    sc_target->${OVERFLOW_MEMBER} = sc_next->${OVERFLOW_MEMBER};`, `    sc_next->${OVERFLOW_MEMBER} = sc_old;`, `  }`);
+    }
+    defs.push(`  ${releaseCallC(t, "sc_next")};`, `}`, ``);
+    return `&${commit}`;
+}
+function streamTypedRefEligible(t) {
+    return t.kind === "record" || t.kind === "array" || t.kind === "bytes";
+}
+/** 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
+ * disappearing into the parent's detached snapshot. */
+function streamTypedRefAdapter(E, t, ctx, preferredSnapshot) {
+    const key = typeKey(t);
+    const existing = ctx.adapters.get(key);
+    if (existing)
+        return existing;
+    const snapshot = preferredSnapshot ??
+        `${ctx.prefix}_nested_${ctx.adapters.size}`;
+    const adapter = { snapshot, commit: "NULL" };
+    /* Register before walking children: recursive record/array types refer
+     * back to this prototype without recursively generating helpers. */
+    ctx.adapters.set(key, adapter);
+    E.walkerProtos.push(`static ScrDyn *${snapshot}(void *sc_p); /* materialize live stream value ${key} */`);
+    adapter.commit = streamTypedRefCommitAdapter(E, t, snapshot, ctx.defs);
+    const box = (child, expr) => {
+        if (!streamTypedRefEligible(child)) {
+            return `${E.toDynHelper(child)}(${expr})`;
+        }
+        const nested = streamTypedRefAdapter(E, child, ctx);
+        const rc = vAdapters(child);
+        const childKey = typeKey(child);
+        const keyLit = cStringLiteral(Buffer.from(childKey, "utf8"));
+        return `scr_dyn_new_typed_ref(${expr}, &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(childKey, "utf8")}, &${nested.snapshot}, ${nested.commit})`;
+    };
+    const lines = [
+        `static ScrDyn *${snapshot}(void *sc_p) { /* materialize live stream value ${key} */`,
+        `  ${cDecl(t, "v")} = (${cType(t).trim()})sc_p;`,
+    ];
+    if (t.kind === "record") {
+        const shape = E.recordsById.get(t.shapeId);
+        if (!shape) {
+            throw new Error(`emitter bug: stream typed-ref materialize of unknown shape ${t.shapeId}`);
+        }
+        const ordinary = shape.indexValue || shape.fields.some((field) => field.name === "handleEvent" && field.type.kind === "func");
+        if (ordinary) {
+            lines.push(`  return ${E.toDynHelper(t)}(v);`, `}`, ``);
+            ctx.defs.push(...lines);
+            return adapter;
+        }
+        if (shape.tuple) {
+            lines.push(`  ScrDyn *d = scr_dyn_new_arr();`);
+            const fields = [...shape.fields].sort((a, b) => Number(a.name) - Number(b.name));
+            for (const field of fields) {
+                lines.push(`  scr_dyn_arr_push(d, ${box(field.type, `v->${mangleField(field.name)}`)});`);
+            }
+        }
+        else {
+            lines.push(`  ScrDyn *d = scr_dyn_new_obj();`);
+            const byName = new Map(shape.fields.map((field) => [field.name, field]));
+            const order = shape.declaredOrder ?? shape.fields.map((field) => field.name);
+            const inOrder = new Set(order);
+            const fields = [
+                ...order.map((name) => byName.get(name)).filter((field) => field !== undefined),
+                ...shape.fields.filter((field) => !inOrder.has(field.name)),
+            ];
+            for (const field of fields) {
+                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 === "array") {
+        const elem = t.elem;
+        lines.push(`  ScrDyn *d = scr_dyn_new_arr();`, `  for (size_t sc_i = 0; sc_i < v->len; sc_i++) {`);
+        if (elem.kind === "f64") {
+            lines.push(`    scr_dyn_arr_push(d, ${box(elem, "scr_arr_get_f64(v, (double)sc_i)")});`);
+        }
+        else if (elem.kind === "bool") {
+            lines.push(`    scr_dyn_arr_push(d, ${box(elem, "scr_arr_get_bool(v, (double)sc_i)")});`);
+        }
+        else {
+            lines.push(`    ${cDecl(elem, "sc_value")} = (${cType(elem).trim()})scr_arr_get_ref(v, (double)sc_i);`, `    scr_dyn_arr_push(d, ${box(elem, "sc_value")});`, `    ${releaseCallC(elem, "sc_value")};`);
+        }
+        lines.push(`  }`, `  return d;`);
+    }
+    else {
+        lines.push(`  return ${E.toDynHelper(t)}(v);`);
+    }
+    lines.push(`}`, ``);
+    ctx.defs.push(...lines);
+    return adapter;
+}
+/** One per-type capsule adapter for Web API arguments whose JavaScript
+ * contract preserves the exact input reference. */
+function liveDynRefAdapter(E, t) {
+    const key = typeKey(t);
+    const existing = E.liveDynRefAdapters.get(key);
+    if (existing)
+        return existing;
+    if (!streamTypedRefEligible(t)) {
+        throw new Error(`emitter bug: live dyn ref of ${key}`);
+    }
+    const prefix = `sc_ldr_${E.liveDynRefAdapters.size}`;
+    const defs = [];
+    const adapter = streamTypedRefAdapter(E, t, { prefix, defs, adapters: new Map() }, `${prefix}_materialize`);
+    E.liveDynRefAdapters.set(key, adapter);
+    E.walkerDefs.push(...defs);
+    return adapter;
+}
+/** A union itself is only the tagged box; the identity Web APIs expose is
+ * the selected mutable arm. Dispatch on the tag and point the typed capsule
+ * directly at that arm's payload. Non-mutable arms keep ordinary dynFrom
+ * semantics. */
+function liveDynUnionRefAdapter(E, t) {
+    const key = typeKey(t);
+    const existing = E.liveDynUnionRefAdapters.get(key);
+    if (existing)
+        return existing;
+    const union = E.unionsById.get(t.unionId);
+    if (!union) {
+        throw new Error(`emitter bug: live dyn ref of unknown union ${t.unionId}`);
+    }
+    const mutableArms = union.arms
+        .map((arm, tag) => ({ arm, tag }))
+        .filter(({ arm }) => streamTypedRefEligible(arm));
+    if (mutableArms.length === 0) {
+        throw new Error(`emitter bug: live dyn ref of immutable union ${key}`);
+    }
+    const sym = `sc_ldu_${E.liveDynUnionRefAdapters.size}`;
+    E.liveDynUnionRefAdapters.set(key, sym);
+    const sig = `static ScrDyn *${sym}(ScrUnion *sc_u)`;
+    E.walkerProtos.push(`${sig}; /* materialize live union value ${key} */`);
+    const defs = [];
+    const adapters = new Map();
+    for (const { arm, tag } of mutableArms) {
+        const prefix = `${sym}_${tag}`;
+        adapters.set(tag, streamTypedRefAdapter(E, arm, { prefix, defs, adapters: new Map() }, `${prefix}_materialize`));
+    }
+    defs.push(`${sig} {`, `  switch (sc_u->tag) {`);
+    for (const { arm, tag } of mutableArms) {
+        const adapter = adapters.get(tag);
+        const rc = vAdapters(arm);
+        const armKey = typeKey(arm);
+        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 ${E.toDynHelper(t)}(sc_u);`, `  }`, `}`, ``);
+    E.walkerDefs.push(...defs);
+    return sym;
+}
+function streamFromArrayAdapter(E, t) {
+    const elem = t.elem;
+    const key = typeKey(elem);
+    const existing = E.streamFromArrayAdapters.get(key);
+    if (existing)
+        return existing;
+    const sym = `sc_sfa_${E.streamFromArrayAdapters.size}`;
+    E.streamFromArrayAdapters.set(key, sym);
+    const sig = `static ScrDyn *${sym}(ScrArr *sc_a, double sc_i)`;
+    E.walkerProtos.push(`${sig}; /* ReadableStream.from array<${key}> */`);
+    const unionDef = elem.kind === "union"
+        ? E.unionsById.get(elem.unionId)
+        : undefined;
+    if (elem.kind === "union" && !unionDef) {
+        throw new Error(`emitter bug: streamFrom of unknown union ${elem.unionId}`);
+    }
+    const unionRefArms = unionDef?.arms
+        .map((arm, tag) => ({ arm, tag }))
+        .filter(({ arm }) => isRefCounted(arm) && arm.kind !== "dyn" && arm.kind !== "string") ?? [];
+    const typedRef = isRefCounted(elem) &&
+        elem.kind !== "dyn" &&
+        elem.kind !== "string" &&
+        elem.kind !== "union";
+    const snapshot = `${sym}_materialize`;
+    const d = [];
+    let commit = "NULL";
+    if (typedRef) {
+        if (streamTypedRefEligible(elem)) {
+            const adapter = streamTypedRefAdapter(E, elem, { prefix: snapshot, defs: d, adapters: new Map() }, snapshot);
+            commit = adapter.commit;
+        }
+        else {
+            const snapshotSig = `static ScrDyn *${snapshot}(void *sc_p)`;
+            E.walkerProtos.push(`${snapshotSig}; /* materialize stream element ${key} */`);
+            d.push(`${snapshotSig} {`, `  return ${E.toDynHelper(elem)}((${cType(elem).trim()})sc_p);`, `}`, ``);
+            commit = streamTypedRefCommitAdapter(E, elem, snapshot, d);
+        }
+    }
+    const unionCommits = new Map();
+    for (const { arm, tag } of unionRefArms) {
+        const armKey = typeKey(arm);
+        const armSnapshot = `${snapshot}_${tag}`;
+        const snapshotSig = `static ScrDyn *${armSnapshot}(void *sc_p)`;
+        E.walkerProtos.push(`${snapshotSig}; /* materialize stream union arm ${armKey} */`);
+        d.push(`${snapshotSig} {`, `  return ${E.toDynHelper(arm)}((${cType(arm).trim()})sc_p);`, `}`, ``);
+        unionCommits.set(tag, streamTypedRefCommitAdapter(E, arm, armSnapshot, d));
+    }
+    d.push(`${sig} { /* ReadableStream.from array<${key}> */`);
+    if (elem.kind === "f64") {
+        d.push(`  return ${E.toDynHelper(elem)}(scr_arr_get_f64(sc_a, sc_i));`);
+    }
+    else if (elem.kind === "bool") {
+        d.push(`  return ${E.toDynHelper(elem)}(scr_arr_get_bool(sc_a, sc_i));`);
+    }
+    else {
+        d.push(`  ${cDecl(elem, "sc_v")} = (${cType(elem).trim()})scr_arr_get_ref(sc_a, sc_i);`);
+        if (elem.kind === "union") {
+            d.push(`  ScrDyn *sc_d;`, `  switch (sc_v->tag) {`);
+            for (const { arm, tag } of unionRefArms) {
+                const armKey = typeKey(arm);
+                const rc = vAdapters(arm);
+                const keyLit = cStringLiteral(Buffer.from(armKey, "utf8"));
+                d.push(`  case ${tag}:`, `    sc_d = scr_dyn_new_typed_ref(scr_union_peek(sc_v), &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(armKey, "utf8")}, &${snapshot}_${tag}, ${unionCommits.get(tag) ?? "NULL"});`, `    break;`);
+            }
+            d.push(`  default:`, `    sc_d = ${E.toDynHelper(elem)}(sc_v);`, `    break;`, `  }`);
+        }
+        else if (typedRef) {
+            const rc = vAdapters(elem);
+            const keyLit = cStringLiteral(Buffer.from(key, "utf8"));
+            const keyLen = Buffer.byteLength(key, "utf8");
+            d.push(`  ScrDyn *sc_d = scr_dyn_new_typed_ref(sc_v, &${rc.retain}, &${rc.release}, ${keyLit}, ${keyLen}, &${snapshot}, ${commit});`);
+        }
+        else {
+            d.push(`  ScrDyn *sc_d = ${E.toDynHelper(elem)}(sc_v);`);
+        }
+        d.push(`  ${releaseCallC(elem, "sc_v")};`, `  return sc_d;`);
+    }
+    d.push(`}`, ``);
+    E.walkerDefs.push(...d);
+    return sym;
+}
+function dynPromiseAdapter(E, inner) {
+    if (!isRefCounted(inner) || inner.kind === "dyn") {
+        throw new Error(`dynamic promise adapter requires a concrete reference type, got ${typeKey(inner)}`);
+    }
+    const key = typeKey(inner);
+    const existing = E.dynPromiseAdapters.get(key);
+    if (existing)
+        return existing;
+    const sym = `sc_dpa_${E.dynPromiseAdapters.size}`;
+    E.dynPromiseAdapters.set(key, sym);
+    const sig = `static void ${sym}(ScrPromise *sc_dst, ScrPromise *sc_src)`;
+    E.walkerProtos.push(`${sig}; /* checked-dynamic promise exit ${key} */`);
+    let fulfill;
+    if (inner.kind === "string") {
+        fulfill = `scr_promise_fulfill_str(sc_dst, sc_v);`;
+    }
+    else {
+        const rc = vAdapters(inner);
+        fulfill = `scr_promise_fulfill_ref(sc_dst, sc_v, &${rc.retain}, &${rc.release}, ${E.traceArgC(inner)});`;
+    }
+    E.walkerDefs.push(`${sig} { /* checked-dynamic promise exit ${key} */`, `  ScrDyn *sc_d = (ScrDyn *)scr_promise_payload_ref(sc_src);`, `  ${cDecl(inner, "sc_v")} = ${E.dynCheckHelper(inner)}(sc_d, NULL);`, `  scr_dyn_release(sc_d);`, `  if (scr_exc_pending()) {`, `    scr_promise_reject_pending(sc_dst);`, `    return;`, `  }`, `  ${fulfill}`, `}`, ``);
+    return sym;
+}
+/** True when evaluating an index/value expression cannot overwrite the bytes
+ * receiver binding. This deliberately small whitelist enables borrowed
+ * receivers in typed-array hot loops while side-effecting/calling shapes
+ * retain the full snapshot ownership required by JS evaluation order. */
+export function isStableBytesOperand(e, receiverLocalId) {
+    switch (e.kind) {
+        case "numLit":
+        case "boolLit":
+        case "varRef":
+        case "incDec":
+            return true;
+        case "assignExpr":
+            // An assignment nested under truthiness/ternary can still produce the
+            // numeric index/value while overwriting the bytes-typed receiver.
+            return e.localId !== receiverLocalId && isStableBytesOperand(e.value, receiverLocalId);
+        case "bin":
+            return (isStableBytesOperand(e.left, receiverLocalId) &&
+                isStableBytesOperand(e.right, receiverLocalId));
+        case "unary":
+        case "toBool":
+            return isStableBytesOperand(e.operand, receiverLocalId);
+        case "logical":
+            return (isStableBytesOperand(e.left, receiverLocalId) &&
+                isStableBytesOperand(e.right, receiverLocalId));
+        case "ternary":
+            return (isStableBytesOperand(e.cond, receiverLocalId) &&
+                isStableBytesOperand(e.then, receiverLocalId) &&
+                isStableBytesOperand(e.else_, receiverLocalId));
+        case "bytesIntrinsic":
+            return ((e.method === "get" || e.method === "length" || e.method === "byteLength") &&
+                e.receiver.kind === "varRef" &&
+                e.args.every((arg) => isStableBytesOperand(arg, receiverLocalId)));
+        default:
+            return false;
+    }
+}
+/** Evaluate a bytes receiver as a borrow when it is a direct, unboxed
+ * binding and all later operands are stable. The binding's scope/global
+ * owner then keeps the value alive, avoiding retain/release traffic around
+ * every indexed access. Any uncertain shape falls back to an owned temp. */
+export function emitBytesReceiver(E, receiver, following) {
+    if (receiver.kind === "varRef" &&
+        following.every((operand) => isStableBytesOperand(operand, receiver.localId))) {
+        const local = E.currentLocals.get(receiver.localId);
+        if (local && !local.boxed) {
+            return E.newBorrowedTemp(receiver.type, mangleLocal(receiver.localId));
+        }
+        if (!local && E.globalsById.has(receiver.localId)) {
+            return E.newBorrowedTemp(receiver.type, mangleGlobal(receiver.localId));
+        }
+    }
+    return E.emitExpr(receiver);
+}
 export function emitExpr(E, e) {
     switch (e.kind) {
         case "numLit":
@@ -1020,17 +1356,26 @@ export function emitExpr(E, e) {
                 E.emitPendingCheck();
                 return t;
             }
-            const r = E.emitExpr(e.receiver);
-            const args = e.args.map((a) => E.emitExpr(a));
             const method = e.method;
+            const directElementAccess = method === "length" || method === "byteLength" || method === "get";
+            const r = directElementAccess
+                ? emitBytesReceiver(E, e.receiver, e.args)
+                : E.emitExpr(e.receiver);
+            const args = e.args.map((a) => E.emitExpr(a));
             switch (method) {
                 case "length":
-                    return E.newTemp(e.type, `scr_bytes_len(${r.name})`);
+                    return E.newTemp(e.type, `(double)${r.name}->len`);
                 case "byteLength":
-                    return E.newTemp(e.type, `scr_bytes_byte_len(${r.name})`);
+                    if (e.receiver.type.kind !== "bytes") {
+                        throw new Error("emitter bug: bytesIntrinsic byteLength on non-bytes");
+                    }
+                    return E.newTemp(e.type, `(double)(${r.name}->len * ${e.receiver.type.elem === "u8" ? "1" : "4"})`);
                 case "get":
                     // Any invalid index traps (the array runtime's discipline).
-                    return E.newTemp(e.type, `scr_bytes_get(${r.name}, ${args[0].name})`);
+                    if (e.receiver.type.kind !== "bytes") {
+                        throw new Error("emitter bug: bytesIntrinsic get on non-bytes");
+                    }
+                    return E.newTemp(e.type, `${E.bytesElementHelper("get", e.receiver.type.elem)}(${r.name}, ${args[0].name})`);
                 case "slice":
                     // Omitted relative indices default like string slice: start 0,
                     // end +Infinity (math.h is always included). Fresh copy, +1.
@@ -1692,6 +2037,17 @@ export function emitExpr(E, e) {
                     : "scr_dyn_new_null()");
             }
             const v = E.emitExpr(e.value);
+            if (e.liveRef) {
+                if (v.type.kind === "union") {
+                    const adapter = liveDynUnionRefAdapter(E, v.type);
+                    return E.newTemp(e.type, `${adapter}(${v.name})`);
+                }
+                const adapter = liveDynRefAdapter(E, v.type);
+                const rc = vAdapters(v.type);
+                const key = typeKey(v.type);
+                const keyLit = cStringLiteral(Buffer.from(key, "utf8"));
+                return E.newTemp(e.type, `scr_dyn_new_typed_ref(${v.name}, &${rc.retain}, &${rc.release}, ${keyLit}, ${Buffer.byteLength(key, "utf8")}, &${adapter.snapshot}, ${adapter.commit})`);
+            }
             if (v.type.kind === "func") {
                 // A closure boxes as the checked-dynamic tree's function kind: retained closure +
                 // the per-signature call thunk + the interned signature key. The
@@ -2039,12 +2395,9 @@ export function emitExpr(E, e) {
                         // engine's own typeof.
                         `(${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE || ${d.name}->kind == SCR_DYN_NULL || scr_dyn_isl_typeof_is(${d.name}, "object"))`
                     : e.test === "truthy"
-                        ? // ToBoolean over the checked-dynamic tree: bool by value; number falsy for
-                            // 0, -0 (== 0 in C), and NaN (self-inequality); string
-                            // falsy when empty; obj/arr/bytes/func/handle always true;
-                            // JSVAL through the runtime's routed arm (the bigint 0n
-                            // edge); the remaining kinds (undefined, null) always false.
-                            `(${d.name}->kind == SCR_DYN_BOOL ? ${d.name}->v.b : ${d.name}->kind == SCR_DYN_NUM ? (${d.name}->v.num == ${d.name}->v.num && ${d.name}->v.num != 0) : ${d.name}->kind == SCR_DYN_STR ? ${d.name}->v.str->len != 0 : ${d.name}->kind == SCR_DYN_JSVAL ? scr_dyn_truthy(${d.name}) : (${d.name}->kind == SCR_DYN_OBJ || ${d.name}->kind == SCR_DYN_ARR || ${d.name}->kind == SCR_DYN_BYTES || ${d.name}->kind == SCR_DYN_FUNC || ${d.name}->kind == SCR_DYN_HANDLE || ${d.name}->kind == SCR_DYN_PROMISE))`
+                        ? // Runtime ToBoolean includes typed-reference capsules and
+                            // keeps this backend in lockstep with LLVM.
+                            `scr_dyn_truthy(${d.name})`
                         : e.test === "error"
                             ? // `u instanceof Error`: the checked-dynamic tree's error encoding — an
                                 // object carrying the reserved "%error" marker key
@@ -2212,6 +2565,7 @@ export function emitExpr(E, e) {
                 const t = e.args[0].type;
                 switch (t.kind) {
                     case "f64":
+                    case "date":
                         E.line(`scr_promise_fulfill_f64(${p.name}, ${v.name});${E.srcComment(e.loc)}`);
                         break;
                     case "bool":
@@ -2294,6 +2648,62 @@ export function emitExpr(E, e) {
             };
             const fn = e.fn;
             switch (fn) {
+                case "fetch.start":
+                    E.usesTimers = true;
+                    return finish(`scr_fetch_static(${arg(0)}, ${arg(1)})`);
+                case "fetch.responseNew":
+                    return finish(`scr_fetch_response_new(${arg(0)}, ${arg(1)})`);
+                case "fetch.responseJson":
+                    return finish(`scr_fetch_response_json(${arg(0)})`);
+                case "fetch.responseText":
+                case "fetch.responseBytes": {
+                    if (e.type.kind !== "promise") {
+                        throw new Error(`emitter bug: ${fn} result`);
+                    }
+                    const runtimeFn = fn === "fetch.responseText"
+                        ? "scr_fetch_response_text"
+                        : "scr_fetch_response_bytes";
+                    const source = E.newTemp({ kind: "promise", inner: DYN }, `${runtimeFn}(${arg(0)})`);
+                    const result = E.newTemp(e.type, `scr_promise_new()`);
+                    const adapter = dynPromiseAdapter(E, e.type.inner);
+                    E.line(`scr_promise_race_add(${result.name}, ${source.name}, &${adapter});${E.srcComment(e.loc)}`);
+                    return result;
+                }
+                case "fetch.abortControllerNew":
+                    return finish(`scr_fetch_abort_controller_new()`);
+                case "fetch.abortTimeout":
+                    E.usesTimers = true;
+                    return finish(`scr_fetch_abort_timeout(${arg(0)})`);
+                case "fetch.abortNow":
+                    return finish(`scr_fetch_abort_now(${arg(0)})`);
+                case "fetch.abortAny":
+                    return finish(`scr_fetch_abort_any(${arg(0)})`);
+                case "fetch.streamNew":
+                    E.usesTimers = true;
+                    return finish(`scr_fetch_stream_new(${arg(0)})`);
+                case "fetch.streamFrom":
+                    E.usesTimers = true;
+                    if (e.args[0].type.kind === "array") {
+                        const adapter = streamFromArrayAdapter(E, e.args[0].type);
+                        return finish(`scr_fetch_stream_from_array(${arg(0)}, &${adapter})`);
+                    }
+                    if (e.args[0].type.kind === "bytes") {
+                        return finish(`scr_fetch_stream_from_bytes(${arg(0)})`);
+                    }
+                    if (e.args[0].type.kind === "string") {
+                        return finish(`scr_fetch_stream_from_string(${arg(0)})`);
+                    }
+                    return finish(`scr_fetch_stream_from(${arg(0)})`);
+                case "fetch.readerRead": {
+                    if (e.type.kind !== "promise" || e.type.inner.kind !== "record") {
+                        throw new Error("emitter bug: fetch.readerRead result");
+                    }
+                    const source = E.newTemp({ kind: "promise", inner: DYN }, `scr_fetch_reader_read(${arg(0)})`);
+                    const result = E.newTemp(e.type, `scr_promise_new()`);
+                    const adapter = dynPromiseAdapter(E, e.type.inner);
+                    E.line(`scr_promise_race_add(${result.name}, ${source.name}, &${adapter});${E.srcComment(e.loc)}`);
+                    return result;
+                }
                 case "island.eval":
                     // --dynamic builds only (the frontend fences the intrinsic, so
                     // scr_island_eval is always linked when this emits). Borrows
@@ -2821,7 +3231,7 @@ export function emitExpr(E, e) {
                     // comes back as f64.
                     return finish(`scr_fs_open(${arg(0)}, ${arg(1)})`);
                 case "fs.readSync":
-                    return finish(`scr_fs_read_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)})`);
+                    return finish(`scr_fs_read_sync(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)})`);
                 case "fs.closeSync":
                     return finish(`scr_fs_close(${arg(0)})`);
                 case "fs.watch":
@@ -5789,7 +6199,17 @@ export function emitExpr(E, e) {
                 case "date.now":
                     // Node's integer milliseconds since epoch. Never throws.
                     return finish(`scr_date_now()`);
+                case "date.newNow":
+                    return finish(`scr_date_now()`);
+                case "date.newMs":
+                    return finish(`scr_date_new_ms(${arg(0)})`);
+                case "date.newString":
+                    return finish(`scr_date_parse_get_time(${arg(0)})`);
+                case "date.getTime":
+                case "date.valueOf":
+                    return finish(`${arg(0)}`);
                 case "date.toISOString":
+                case "date.toISOStringValue":
                     // +1 string, or Node's "Invalid time value" RangeError
                     // (may-throw seed set).
                     return finish(`scr_date_to_iso(${arg(0)})`);
@@ -5801,6 +6221,39 @@ export function emitExpr(E, e) {
                     // MakeDay/MakeTime/TimeClip over seven completed number
                     // arguments; NaN outside the time range. Never throws.
                     return finish(`scr_date_utc(${arg(0)}, ${arg(1)}, ${arg(2)}, ${arg(3)}, ${arg(4)}, ${arg(5)}, ${arg(6)})`);
+                case "date.getFullYear":
+                    return finish(`scr_date_get_full_year(${arg(0)}, false)`);
+                case "date.getUTCFullYear":
+                    return finish(`scr_date_get_full_year(${arg(0)}, true)`);
+                case "date.getMonth":
+                    return finish(`scr_date_get_month(${arg(0)}, false)`);
+                case "date.getUTCMonth":
+                    return finish(`scr_date_get_month(${arg(0)}, true)`);
+                case "date.getDate":
+                    return finish(`scr_date_get_date(${arg(0)}, false)`);
+                case "date.getUTCDate":
+                    return finish(`scr_date_get_date(${arg(0)}, true)`);
+                case "date.getDay":
+                    return finish(`scr_date_get_day(${arg(0)}, false)`);
+                case "date.getUTCDay":
+                    return finish(`scr_date_get_day(${arg(0)}, true)`);
+                case "date.getHours":
+                    return finish(`scr_date_get_hours(${arg(0)}, false)`);
+                case "date.getUTCHours":
+                    return finish(`scr_date_get_hours(${arg(0)}, true)`);
+                case "date.getMinutes":
+                    return finish(`scr_date_get_minutes(${arg(0)}, false)`);
+                case "date.getUTCMinutes":
+                    return finish(`scr_date_get_minutes(${arg(0)}, true)`);
+                case "date.getSeconds":
+                    return finish(`scr_date_get_seconds(${arg(0)}, false)`);
+                case "date.getUTCSeconds":
+                    return finish(`scr_date_get_seconds(${arg(0)}, true)`);
+                case "date.getMilliseconds":
+                case "date.getUTCMilliseconds":
+                    return finish(`scr_date_get_milliseconds(${arg(0)})`);
+                case "date.getTimezoneOffset":
+                    return finish(`scr_date_get_timezone_offset(${arg(0)})`);
                 case "text.decode":
                     // WHATWG utf-8 decode with the leading BOM stripped
                     // (scr_bytes.c). Borrowed bytes; +1 string; never throws.
@@ -5959,7 +6412,7 @@ export function emitExpr(E, e) {
                 throw new Error("emitter bug: yieldExpr with no operand (frontend fills undefined)");
             const v = E.emitExpr(e.value);
             const yt = e.value.type;
-            if (yt.kind === "f64") {
+            if (yt.kind === "f64" || yt.kind === "date") {
                 E.line(`scr_gen_yield_f64(${v.name});${E.srcComment(e.loc)}`);
             }
             else if (yt.kind === "bool") {
@@ -5976,6 +6429,7 @@ export function emitExpr(E, e) {
                     // fences value-position yields on this channel).
                     return { name: "", type: e.type };
                 case "f64":
+                case "date":
                     return E.newTemp(e.type, `scr_gen_take_in_f64()`);
                 case "bool":
                     return E.newTemp(e.type, `scr_gen_take_in_bool()`);
@@ -6013,7 +6467,7 @@ export function emitExpr(E, e) {
                 }
                 else {
                     const nt = e.arg.type;
-                    sendArg((a) => nt.kind === "f64" ? `scr_gen_in_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
+                    sendArg((a) => nt.kind === "f64" || nt.kind === "date" ? `scr_gen_in_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                         : nt.kind === "bool" ? `scr_gen_in_bool(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                             : `scr_gen_in_ref(${g.name}, ${a.name}, ${vAdapters(nt).release});${E.srcComment(e.loc)}`);
                 }
@@ -6025,7 +6479,7 @@ export function emitExpr(E, e) {
                 }
                 else {
                     const rt = e.arg.type;
-                    sendArg((a) => rt.kind === "f64" ? `scr_gen_ret_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
+                    sendArg((a) => rt.kind === "f64" || rt.kind === "date" ? `scr_gen_ret_f64(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                         : rt.kind === "bool" ? `scr_gen_ret_bool(${g.name}, ${a.name});${E.srcComment(e.loc)}`
                             : `scr_gen_ret_ref(${g.name}, ${a.name}, ${vAdapters(rt).release});${E.srcComment(e.loc)}`);
                 }
@@ -6042,7 +6496,10 @@ export function emitExpr(E, e) {
                 const t = e.arg.type;
                 if (isRefCounted(t))
                     E.moveTemp(a); // the cell takes ownership
-                if (t.kind === "f64") {
+                if (t.kind === "date") {
+                    throw new Error("emitter bug: Date generator throw reached backend");
+                }
+                else if (t.kind === "f64") {
                     E.line(`scr_throw_f64(${a.name});${E.srcComment(e.loc)}`);
                 }
                 else if (t.kind === "bool") {
@@ -6075,6 +6532,7 @@ export function emitExpr(E, e) {
             let read;
             switch (e.type.kind) {
                 case "f64":
+                case "date":
                     read = `scr_await_f64(${pr.name})`;
                     break;
                 case "bool":
@@ -6197,6 +6655,7 @@ export function emitExpr(E, e) {
             let mk;
             switch (inner.kind) {
                 case "f64":
+                case "date":
                     mk = `scr_make_resolve(${p.name}, 0)`;
                     break;
                 case "bool":
@@ -6251,6 +6710,7 @@ export function emitExpr(E, e) {
             let mk;
             switch (inner.kind) {
                 case "f64":
+                case "date":
                     mk = `scr_make_resolve(${p.name}, 0)`;
                     break;
                 case "bool":
@@ -6421,6 +6881,10 @@ export function emitExpr(E, e) {
                     const pack = argPack(args.slice(1).map((x) => x.name));
                     return finishFallible(`scr_jsval_call_method(${a(0)}, ${nameSym()}, ${args.length - 1}, ${pack})`);
                 }
+                case "callFnThis": {
+                    const pack = argPack(args.slice(2).map((x) => x.name));
+                    return finishFallible(`scr_jsval_call_this(${a(0)}, ${a(1)}, ${args.length - 2}, ${pack})`);
+                }
                 case "callFn": {
                     const pack = argPack(args.slice(1).map((x) => x.name));
                     return finishFallible(`scr_jsval_call(${a(0)}, ${args.length - 1}, ${pack})`);