@scriptc/compiler 0.0.6 → 0.0.8

package/dist/frontend/lowering/lower-calls.js

@@ -16,7 +16,7 @@ import { bufEncoding, dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilter
 import { lowerChildStreamMethodCall, lowerDirentMethodCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerWatcherMethodCall } from "./lower-builtins.js";
 import { lowerPromiseAllTupleCall, lowerPromiseRejectCall, probeLower, templateRawTextOf } from "./lower-exprs.js";
 import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerHttpClientFnCall } from "./lower-server.js";
-import { EMITTER_API_MEMBERS, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall } from "./lower-classes.js";
+import { EMITTER_API_MEMBERS, exactInstanceClassOf, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall } from "./lower-classes.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-emitter.js";
 import { lowerConsoleInspectArg, lowerFormatCall } from "./lower-inspect.js";
 import { STREAM_API_MEMBERS, lowerStreamMethodCall, lowerStreamModuleCall, lowerStreamStaticCall, streamSidesOf } from "./lower-stream.js";
@@ -107,9 +107,20 @@ export function paramShape(L, param) {
         // ARRAY param the dyn call thunk fills with the call's surplus
         // arguments; the binding is that array (dynRest — funcType marks
         // `rest`, and the value only ever calls through the boxed thunk).
-        if (isJsSourceFile(param.getSourceFile()) &&
-            L.mapTypeOf(L.typeOf(param.name))?.kind !== "array") {
-            return { type: DYN, mode: "dynRest" };
+        if (isJsSourceFile(param.getSourceFile())) {
+            const restMapped = L.mapTypeOf(L.typeOf(param.name));
+            // `any[]` under --dynamic maps to an island-element array — that
+            // is inference residue, not element information; the binding is
+            // the ENGINE's own arguments array (an island handle) and the
+            // value crosses as a REST host function (the withPlugins
+            // `async (...args) =>` shape). Static builds keep the variadic
+            // dyn form for every unmappable JS rest.
+            if (restMapped?.kind === "array" && restMapped.elem.kind === "jsval" && L.dynamic) {
+                return { type: JSVAL, mode: "islandRest" };
+            }
+            if (restMapped?.kind !== "array") {
+                return { type: DYN, mode: "dynRest" };
+            }
         }
         const type = L.irTypeOf(param.name);
         // Tuple-typed rest params don't map to an array; generic rest is the
@@ -213,7 +224,7 @@ export function completeArgs(L, argNodes, shapes, loc, blame,
 leading) {
     const isIr = (s) => s !== undefined && !("kind" in s);
     const sources = leading && leading.length > 0 ? [...leading.map((ir) => ({ ir })), ...argNodes] : argNodes;
-    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest");
+    const restAt = shapes.findIndex((s) => s.mode === "rest" || s.mode === "dynRest" || s.mode === "islandRest");
     const positional = restAt >= 0 ? shapes.slice(0, restAt) : [...shapes];
     const out = positional.map((shape, i) => {
         const src = sources[i];
@@ -243,7 +254,21 @@ leading) {
         }
         return L.undefinedArgFor(shape.type, loc, blame);
     });
-    if (restAt >= 0 && shapes[restAt].mode === "dynRest") {
+    if (restAt >= 0 && shapes[restAt].mode === "islandRest") {
+        // The ISLAND variadic pack: surplus arguments marshal into one
+        // fresh ENGINE array — exactly what the REST host-call adapter
+        // hands the closure for indirect calls.
+        const elems = sources.slice(restAt).map((a) => {
+            if (isIr(a))
+                return L.coerceInto(blame, a.ir, JSVAL);
+            if (ts.isSpreadElement(a)) {
+                L.unsupported("SC1090", a, "spread arguments into an island rest parameter");
+            }
+            return L.lowerExprExpecting(a, JSVAL);
+        });
+        out.push({ kind: "jsOp", op: "arrLit", args: elems, type: JSVAL, loc });
+    }
+    else if (restAt >= 0 && shapes[restAt].mode === "dynRest") {
         // The VARIADIC dyn pack (a JS `...args` with no static element
         // type, or the synthetic `arguments` slot): surplus arguments
         // convert through the dyn boundary into one fresh DOM array —
@@ -405,6 +430,7 @@ export function requireExactArityValue(L, blame, contextual, shapes, funcType) {
     // tier's undefined (omittedArgFor).
     if (shapes.every((s) => s.mode === "required" ||
         s.mode === "dynRest" ||
+        s.mode === "islandRest" ||
         (s.mode === "omittable" && (s.type.kind === "dyn" || s.type.kind === "jsval")))) {
         return;
     }
@@ -831,24 +857,61 @@ export function genericCallInstance(L, expr, info) {
         fenceGenericSignatureResult(L, expr, retTs);
         L.badType(expr, retTs);
     }
-    return internGenericInstance(L, expr, info, params, returnType, () => L.inferTypeParamBindings(expr, info, rsig));
+    // keyof-constrained type parameters (`K extends keyof T`): the bound
+    // LITERAL is semantic — the instance body reads the named field — so
+    // the bindings compute EAGERLY (the key needs them) and each literal
+    // keys its own instance (`pick(o, "a")` and `pick(o, "b")` map to the
+    // same IR signature when the fields agree, but their bodies read
+    // different fields). Non-literal bindings (a key union, plain string)
+    // share one runtime-keyed instance per IR signature, exactly the
+    // widened discipline.
+    const keyofTps = keyofConstrainedTypeParams(info);
+    if (keyofTps.size > 0) {
+        const tsBindings = new Map();
+        const bindings = L.inferTypeParamBindings(expr, info, rsig, tsBindings);
+        const litKey = info.typeParams
+            .filter((tp) => keyofTps.has(tp))
+            .map((tp) => {
+            const bound = tsBindings.get(tp);
+            return bound?.isStringLiteralType() ? JSON.stringify(bound.value)
+                : bound?.isNumberLiteralType() ? String(bound.value)
+                    : "*";
+        })
+            .join(",");
+        return internGenericInstance(L, expr, info, params, returnType, () => bindings, {
+            extraKey: `@${litKey}`,
+            tsBindings,
+        });
+    }
+    return internGenericInstance(L, expr, info, params, returnType, (tsBindings) => L.inferTypeParamBindings(expr, info, rsig, tsBindings));
 }
 /** The one instance table both instantiation routes share: key identity IS
    * signature identity, so a call (`identity(1)`) and a pinned VALUE
    * (`const f: (x: number) => number = identity`) reuse one compiled
    * instance. `makeBindings` runs only for a NEW key (binding inference
    * costs checker walks). */
-export function internGenericInstance(L, blame, info, params, returnType, makeBindings) {
-    const key = `${params.map((s) => typeKey(s.type)).join(",")}=>${typeKey(returnType)}`;
+export function internGenericInstance(L, blame, info, params, returnType, makeBindings, opts) {
+    // keyof-constrained instantiations append their literal keys
+    // (extraKey): the IR signature alone under-discriminates there — two
+    // literals can map to one IR signature while their bodies read
+    // different fields.
+    const key = `${params.map((s) => typeKey(s.type)).join(",")}=>${typeKey(returnType)}${opts?.extraKey ?? ""}`;
     let inst = info.instances.get(key);
     if (!inst) {
         if (info.instances.size >= MAX_GENERIC_INSTANCES) {
             L.unsupported("SC1090", blame, `unbounded generic instantiation ('${info.baseName}' exceeded ` +
                 `${MAX_GENERIC_INSTANCES} instances — polymorphic recursion?)`);
         }
-        const bindings = makeBindings();
+        const tsBindings = opts?.tsBindings ?? new Map();
+        const bindings = makeBindings(tsBindings);
         const rendered = info.typeParams
             .map((tp) => {
+            // A literal-bound keyof parameter renders its literal — the
+            // instance is per-literal, and '<…, string>' would misname it.
+            const tsBound = tsBindings.get(tp);
+            if (info.keyofTps?.has(tp) && tsBound?.isStringLiteralType()) {
+                return JSON.stringify(tsBound.value);
+            }
             const bound = bindings.get(tp);
             return bound ? L.fmt(bound) : tp.name;
         })
@@ -861,6 +924,7 @@ export function internGenericInstance(L, blame, info, params, returnType, makeBi
             params,
             returnType,
             bindings,
+            tsBindings,
             typeArgsText,
         };
         info.instances.set(key, inst);
@@ -868,40 +932,65 @@ export function internGenericInstance(L, blame, info, params, returnType, makeBi
     }
     return inst;
 }
+/** The type parameters of `info` declared with a `keyof` CONSTRAINT
+   * (`K extends keyof T`) — the parameters whose bound literal is semantic
+   * (the body's `o[k]` reads the named field), computed once per info from
+   * the declaration's syntax. */
+export function keyofConstrainedTypeParams(info) {
+    if (info.keyofTps)
+        return info.keyofTps;
+    const out = new Set();
+    info.decl.typeParameters?.forEach((tpDecl, i) => {
+        const sym = info.typeParams[i];
+        if (!sym || tpDecl.constraint === undefined)
+            return;
+        if (ts.isTypeOperatorNode(tpDecl.constraint) && tpDecl.constraint.operator === ts.SyntaxKind.KeyOfKeyword) {
+            out.add(sym);
+        }
+    });
+    info.keyofTps = out;
+    return out;
+}
 /** Type-parameter symbol → concrete IR type for one instantiation.
    * Explicit type arguments bind directly; the rest come from structurally
    * matching each DECLARED param/return type (which mentions the type
    * parameters) against the checker's INSTANTIATED one — the latter is the
    * former with the substitution applied, so the shapes are parallel by
    * construction. A type parameter left unbound only matters if the body
-   * mentions it, where mapType fails with SC2001 (carrying the
-   * instantiation context). */
-export function inferTypeParamBindings(L, expr, info, rsig) {
+   * mentions it, where mapType fails and badType names the shape
+   * (carrying the instantiation context). */
+export function inferTypeParamBindings(L, expr, info, rsig, tsBindings) {
     const bindings = new Map();
     expr.typeArguments?.forEach((ta, i) => {
         const tp = info.typeParams[i];
         if (!tp)
             return;
-        const mapped = L.mapTypeOf(L.checker.getTypeFromTypeNode(ta));
-        if (mapped && mapped.kind !== "void")
+        const taT = L.checker.getTypeFromTypeNode(ta);
+        const mapped = L.mapTypeOf(taT);
+        if (mapped && mapped.kind !== "void") {
             bindings.set(tp, mapped);
+            tsBindings?.set(tp, taT);
+        }
     });
-    unifySignatureBindings(L, info, rsig, bindings);
-    bindDefaultTypeParams(L, info.typeParams, info.decl.typeParameters, bindings);
+    unifySignatureBindings(L, info, rsig, bindings, tsBindings);
+    bindDefaultTypeParams(L, info.typeParams, info.decl.typeParameters, bindings, tsBindings);
     return bindings;
 }
 /** Type parameters still unbound after unification take their declared
    * DEFAULT (`<T = number>`), mapped — the checker already substituted the
    * default into every resolved signature, so this only fills the bindings
    * an instance body's mapType consults. */
-export function bindDefaultTypeParams(L, typeParams, typeParamDecls, bindings) {
+export function bindDefaultTypeParams(L, typeParams, typeParamDecls, bindings, tsBindings) {
     typeParamDecls?.forEach((tpDecl, i) => {
         const tp = typeParams[i];
         if (!tp || bindings.has(tp) || !tpDecl.defaultType)
             return;
-        const mapped = L.mapTypeOf(L.checker.getTypeFromTypeNode(tpDecl.defaultType));
-        if (mapped && mapped.kind !== "void")
+        const defT = L.checker.getTypeFromTypeNode(tpDecl.defaultType);
+        const mapped = L.mapTypeOf(defT);
+        if (mapped && mapped.kind !== "void") {
             bindings.set(tp, mapped);
+            tsBindings?.set(tp, defT);
+        }
     });
 }
 /** The structural half of binding inference: unify the DECLARED signature
@@ -910,7 +999,7 @@ export function bindDefaultTypeParams(L, typeParams, typeParamDecls, bindings) {
    * completed signature a VALUE reference is pinned to (the contextual
    * type's one call signature). Mutates `bindings`; already-bound
    * parameters (explicit type arguments) win. */
-export function unifySignatureBindings(L, info, rsig, bindings) {
+export function unifySignatureBindings(L, info, rsig, bindings, tsBindings) {
     const tpSet = new Set(info.typeParams);
     const seen = new Set(); // recursive declared types must not loop
     // The identity-keyed set cannot catch LAZILY INFINITE anonymous types
@@ -927,10 +1016,22 @@ export function unifySignatureBindings(L, info, rsig, bindings) {
             return;
         if (declared.flags & ts.TypeFlags.TypeParameter) {
             const sym = declared.getSymbol();
-            if (sym && tpSet.has(sym) && !bindings.has(sym)) {
-                const mapped = L.mapTypeOf(inst);
-                if (mapped && mapped.kind !== "void")
-                    bindings.set(sym, mapped);
+            if (sym && tpSet.has(sym)) {
+                // The checker type records even when an explicit type argument
+                // already bound the IrType: the raw type is the SAME binding
+                // pre-widening, and first-hit-wins keeps the two maps parallel.
+                // A generic body FORWARDING its own parameter (`pluck`'s
+                // `pick(it, key)` binds pick's K to pluck's K) resolves through
+                // the enclosing instantiation's ts bindings first — the literal
+                // carries through the chain.
+                if (tsBindings && !tsBindings.has(sym)) {
+                    tsBindings.set(sym, L.typeParamTsResolver(inst) ?? inst);
+                }
+                if (!bindings.has(sym)) {
+                    const mapped = L.mapTypeOf(inst);
+                    if (mapped && mapped.kind !== "void")
+                        bindings.set(sym, mapped);
+                }
             }
             return;
         }
@@ -1049,6 +1150,13 @@ export function lowerGenericInstance(L, info, inst) {
     L.typeParamBindings = clsBindings
         ? new Map([...clsBindings, ...inst.bindings])
         : inst.bindings;
+    // The ts-level bindings ride along: `T[K]` and literal-keyed `o[k]`
+    // reads inside the body resolve through the bound CHECKER types
+    // (typeParamTsResolver). Generic-class instantiations carry no
+    // ts-level bindings (their type arguments widened at the reference),
+    // so only the method instantiation's own map installs.
+    const prevTsBindings = L.typeParamTsBindings;
+    L.typeParamTsBindings = inst.tsBindings ?? null;
     // Implicit-any instances thread their param bindings through typeOf
     // (the checker reports `any` inside the body — there is no T for
     // mapType to substitute); see the implicit-monomorphization section.
@@ -1186,6 +1294,7 @@ export function lowerGenericInstance(L, info, inst) {
         L.fnStack.pop();
         L.currentClass = prevClass;
         L.typeParamBindings = prevBindings;
+        L.typeParamTsBindings = prevTsBindings;
         L.implicitParamTypes = prevImplicit;
         L.instantiationContext = prevContext;
         L.suppressStats = prevSuppress;
@@ -2591,6 +2700,37 @@ export function lowerCall(L, expr) {
                     : "value";
             return { kind: "dynCall", callee, calleeName, args, type: DYN, loc };
         }
+        // `fn(...args)` — a TRAILING spread into an island call: the
+        // engine's own apply (`fn.apply(undefined, argsArray)`); leading
+        // plain arguments prepend through `[l1, l2].concat(argsArray)`
+        // (concat flattens the array argument one level — exactly the
+        // spread). Other spread shapes keep the syntax fence.
+        if (expr.arguments.length > 0 &&
+            ts.isSpreadElement(expr.arguments[expr.arguments.length - 1]) &&
+            expr.arguments.slice(0, -1).every((a) => !ts.isSpreadElement(a))) {
+            const spread = expr.arguments[expr.arguments.length - 1];
+            const spreadV = L.jsvalIn(L.lowerExpr(spread.expression), spread.expression);
+            const leading = expr.arguments.slice(0, -1).map((a) => L.jsvalIn(L.lowerExpr(a), a));
+            const argsArr = leading.length === 0
+                ? spreadV
+                : {
+                    kind: "jsOp",
+                    op: "callMethod",
+                    name: "concat",
+                    args: [{ kind: "jsOp", op: "arrLit", args: leading, type: JSVAL, loc }, spreadV],
+                    type: JSVAL,
+                    loc,
+                };
+            const result = {
+                kind: "jsOp",
+                op: "callMethod",
+                name: "apply",
+                args: [callee, { kind: "jsOp", op: "undefLit", args: [], type: JSVAL, loc }, argsArr],
+                type: JSVAL,
+                loc,
+            };
+            return islandPrimitiveExit(L, expr, result);
+        }
         const args = expr.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
         const result = { kind: "jsOp", op: "callFn", args: [callee, ...args], type: JSVAL, loc };
         return islandPrimitiveExit(L, expr, result);
@@ -4044,11 +4184,26 @@ export function lowerTaggedTemplate(L, expr) {
         : expr.template.templateSpans.map((s) => s.expression);
     // Island tags (--dynamic): the engine call forms, mirroring lowerCall's
     // island paths — a property-access tag is a method call (this = the
-    // receiver, JS-exact), any other island tag a function call.
+    // receiver, JS-exact), any other island tag a function call. The
+    // strings argument builds ENGINE-NATIVE with its `.raw` property (the
+    // tplStrings op): a JSON marshal would drop `.raw`, and tags dispatch
+    // on it (the outdent idiom treats a raw-less argument as its OPTIONS
+    // form and answers a function). A fresh array per evaluation — tags
+    // caching by strings identity re-compute per call (SEMANTICS.md).
+    const islandStrings = () => ({
+        kind: "jsOp",
+        op: "tplStrings",
+        args: [
+            ...pieces.map((p) => ({ kind: "jsMarshal", value: { kind: "strLit", value: p.text, type: STRING, loc }, type: JSVAL, loc })),
+            ...pieces.map((p) => ({ kind: "jsMarshal", value: { kind: "strLit", value: templateRawTextOf(p), type: STRING, loc }, type: JSVAL, loc })),
+        ],
+        type: JSVAL,
+        loc,
+    });
     if (ts.isPropertyAccessExpression(expr.tag) && L.isIslandExpr(expr.tag.expression)) {
         const receiver = L.lowerExpr(expr.tag.expression);
         const args = [
-            L.jsvalIn(strings, expr.template),
+            islandStrings(),
             ...values.map((a) => L.jsvalIn(L.lowerExpr(a), a)),
         ];
         return {
@@ -4059,7 +4214,7 @@ export function lowerTaggedTemplate(L, expr) {
     if (L.isIslandExpr(expr.tag)) {
         const callee = L.lowerExpr(expr.tag);
         const args = [
-            L.jsvalIn(strings, expr.template),
+            islandStrings(),
             ...values.map((a) => L.jsvalIn(L.lowerExpr(a), a)),
         ];
         return { kind: "jsOp", op: "callFn", args: [callee, ...args], type: JSVAL, loc };
@@ -4247,6 +4402,7 @@ export function lambdaSignature(L, node) {
     // use a rest parameter. Arrows never claim it (JS: an arrow's
     // `arguments` is the enclosing function's).
     const hasDynRest = shapes.some((s) => s.mode === "dynRest");
+    const hasIslandRest = shapes.some((s) => s.mode === "islandRest");
     const usesArguments = !hasDynRest &&
         !ts.isArrowFunction(node) &&
         isJsSourceFile(node.getSourceFile()) &&
@@ -4258,9 +4414,14 @@ export function lambdaSignature(L, node) {
         shapes,
         funcType: {
             kind: "func",
+            // dynRest is EXCLUDED (the boxed thunk fills the trailing DOM
+            // array — no spelled slot); islandRest is INCLUDED (the trailing
+            // jsval param IS the engine arguments array, the REST host-call
+            // adapter's one uniform shape).
             params: shapes.filter((s) => s.mode !== "dynRest").map((s) => s.type),
             ret,
-            ...(hasDynRest || usesArguments ? { rest: true } : {}),
+            ...(hasDynRest || usesArguments || hasIslandRest ? { rest: true } : {}),
+            ...(hasIslandRest ? { restAbi: "jsval" } : {}),
         },
     };
 }
@@ -4331,13 +4492,14 @@ export function lowerLambda(L, node) {
     if (isGenerator && funcType.ret.kind === "generator") {
         fnCtx.generator = { yieldT: funcType.ret.yieldT, nextT: funcType.ret.nextT };
     }
+    const diagsBefore = L.diags.length;
     L.fnStack.push(fnCtx);
     try {
         const { params, prologue } = L.declareParams(node.parameters, shapes);
         // The VARIADIC `arguments` form (rest-marked with no declared rest
         // param): a synthetic trailing DOM-array param carries the call's
         // arguments; `arguments` reads resolve to it (identifier lowering).
-        if (funcType.rest && !shapes.some((s) => s.mode === "dynRest")) {
+        if (funcType.rest && !shapes.some((s) => s.mode === "dynRest" || s.mode === "islandRest")) {
             const argsLocal = L.declareHiddenLocal("%arguments", DYN);
             params.push({ localId: argsLocal.id, name: "%arguments", type: DYN });
             fnCtx.argumentsLocal = argsLocal;
@@ -4416,6 +4578,53 @@ export function lowerLambda(L, node) {
         L.liftedFns.push(lifted);
         return { kind: "closure", fnName, captures: ctx.captureSources, type: funcType, loc };
     }
+    catch (e) {
+        // JS sources defer LAMBDA poisons like function declarations
+        // (lowerFunction's catch, lambda form — entry the function-level
+        // deferral): a fenced concise body (`(list) => new Intl.ListFormat
+        // (...).format(list)` — the error-message list-join idiom) would
+        // otherwise poison the ENCLOSING statement, stopping module init
+        // where Node only stops when the lambda is CALLED. The value
+        // compiles as a capture-free closure over a runtimeFence body —
+        // calling throws the first captured diagnostic at its source
+        // position. ICEs (SC9001) stay compile errors, exactly like
+        // lowerStmts; probe mode (diagSink) keeps the poison.
+        if (!(e instanceof PoisonError))
+            throw e;
+        if (!isJsSourceFile(node.getSourceFile()) ||
+            L.diagSink !== null ||
+            L.diags.length <= diagsBefore ||
+            L.diags.slice(diagsBefore).some((d) => d.code === "SC9001")) {
+            throw e;
+        }
+        const captured = L.diags.splice(diagsBefore);
+        L.runtimeFences.push(...captured);
+        const first = captured[0];
+        const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? node.getSourceFile(), first.loc.start);
+        const params = funcType.params.map((t, i) => ({ localId: `%pf${i}`, name: `%pf${i}`, type: t }));
+        const lifted = {
+            name: fnName,
+            params,
+            returnType: bodyReturn,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            captures: [],
+            body: [
+                {
+                    kind: "runtimeFence",
+                    code: first.code,
+                    message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
+                    loc,
+                },
+            ],
+            loc,
+        };
+        if (isAsync)
+            lifted.async = true;
+        if (fnCtx.generator)
+            lifted.generator = fnCtx.generator;
+        L.liftedFns.push(lifted);
+        return { kind: "closure", fnName, captures: [], type: funcType, loc };
+    }
     finally {
         L.fnStack.pop();
     }
@@ -5304,8 +5513,8 @@ function filterNarrowHelper(L, test, elem, outElem, tag, loc) {
  * (Symbol.iterator, Symbol.asyncIterator, Symbol.toStringTag, ...) —
  * language-level protocol uses (for-of, template literals) already
  * compile through their constructs without reifying the symbol, so the
- * VALUE forms fence with a named message rather than the generic
- * SymbolConstructor SC2001. */
+ * VALUE forms fence with a named message rather than a blanket
+ * SymbolConstructor type fence. */
 function lowerSymbolStaticCall(L, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -5435,6 +5644,110 @@ export function recordKeysArrayCall(L, receiver, argIr, shape, loc) {
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
+/** Interned `%obj.hasOwn.<n>(r, k)` — Object.hasOwn's membership walk
+ * over a signature-free record shape: the key compares against each
+ * declared field name, undefined-armed fields answering by their tag
+ * (a key is own exactly when Object.keys would list it — the two share
+ * the guard), everything else true, no match false. */
+function recordHasOwnHelper(L, shapeId, loc) {
+    const key = `obj.hasOwn:${shapeId}`;
+    const existing = L.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const helper = `%obj.hasOwn.${L.arrHofHelpers.size}`;
+    L.arrHofHelpers.set(key, helper);
+    const shape = L.shapes.get(shapeId);
+    const recT = { kind: "record", shapeId };
+    const rRef = { kind: "varRef", localId: "r.0", type: recT, loc };
+    const kRef = { kind: "varRef", localId: "k.0", type: STRING, loc };
+    const body = [];
+    for (const f of shape.fields) {
+        const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
+        const answer = utag >= 0 && f.type.kind === "union"
+            ? {
+                kind: "unionIsTag",
+                unionId: f.type.unionId,
+                tag: utag,
+                negated: true,
+                value: { kind: "recordGet", obj: rRef, shapeId, field: f.name, type: f.type, loc },
+                type: BOOL,
+                loc,
+            }
+            : { kind: "boolLit", value: true, type: BOOL, loc };
+        body.push({
+            kind: "if",
+            cond: { kind: "strEq", negated: false, left: kRef, right: { kind: "strLit", value: f.name, type: STRING, loc }, type: BOOL, loc },
+            then: [{ kind: "return", value: answer, loc }],
+            else_: null,
+            loc,
+        });
+    }
+    body.push({ kind: "return", value: { kind: "boolLit", value: false, type: BOOL, loc }, loc });
+    L.liftedFns.push({
+        name: helper,
+        params: [
+            { localId: "r.0", name: "r", type: recT },
+            { localId: "k.0", name: "k", type: STRING },
+        ],
+        returnType: BOOL,
+        locals: [
+            { id: "r.0", name: "r", type: recT, mutable: true },
+            { id: "k.0", name: "k", type: STRING, mutable: false },
+        ],
+        body,
+        loc,
+    });
+    return helper;
+}
+/** Interned `%obj.assign.<n>(t, s)` — Object.assign's per-field copy
+ * over signature-free records (every source field lands on a same-named,
+ * same-typed target field — the caller's gate): undefined-armed source
+ * fields copy behind the not-undefined guard, everything else straight,
+ * and the TARGET returns (JS's aliasing). */
+function recordAssignHelper(L, targetShapeId, srcShapeId, loc) {
+    const key = `obj.assign:${targetShapeId}:${srcShapeId}`;
+    const existing = L.arrHofHelpers.get(key);
+    if (existing)
+        return existing;
+    const helper = `%obj.assign.${L.arrHofHelpers.size}`;
+    L.arrHofHelpers.set(key, helper);
+    const sShape = L.shapes.get(srcShapeId);
+    const tT = { kind: "record", shapeId: targetShapeId };
+    const sT = { kind: "record", shapeId: srcShapeId };
+    const tRef = { kind: "varRef", localId: "t.0", type: tT, loc };
+    const sRef = { kind: "varRef", localId: "s.0", type: sT, loc };
+    const body = [];
+    for (const f of sShape.fields) {
+        const get = { kind: "recordGet", obj: sRef, shapeId: srcShapeId, field: f.name, type: f.type, loc };
+        const set = { kind: "recordSet", obj: tRef, shapeId: targetShapeId, field: f.name, value: get, loc };
+        const utag = f.type.kind === "union" ? L.armTag(f.type.unionId, UNDEFINED_T) : -1;
+        body.push(utag >= 0 && f.type.kind === "union"
+            ? {
+                kind: "if",
+                cond: { kind: "unionIsTag", unionId: f.type.unionId, tag: utag, negated: true, value: get, type: BOOL, loc },
+                then: [set],
+                else_: null,
+                loc,
+            }
+            : set);
+    }
+    body.push({ kind: "return", value: tRef, loc });
+    L.liftedFns.push({
+        name: helper,
+        params: [
+            { localId: "t.0", name: "t", type: tT },
+            { localId: "s.0", name: "s", type: sT },
+        ],
+        returnType: tT,
+        locals: [
+            { id: "t.0", name: "t", type: tT, mutable: true },
+            { id: "s.0", name: "s", type: sT, mutable: true },
+        ],
+        body,
+        loc,
+    });
+    return helper;
+}
 /** The `Iterator` global's statics (ES2025 — Iterator.from, and the
  * abstract constructor as a value): no first-class iterator objects
  * exist here, so every member fences with the working spelling named
@@ -5504,6 +5817,53 @@ function lowerObjectStaticCall(L, call, access) {
         const merged = lowerObjectAssignIndexShape(L, call);
         if (merged)
             return merged;
+        // `Object.assign(target, source)` over signature-free RECORDS whose
+        // source fields all land on same-named, same-typed target fields
+        // (the mockable-clock restore: `Object.assign(mocked,
+        // implementations)` over one shape): the per-field copy helper,
+        // returning the TARGET — JS's aliasing, the target mutates in
+        // place. Undefined-armed source fields copy behind the
+        // not-undefined guard (an omitted optional field holds the
+        // undefined arm and must not erase the target's value — Node
+        // copies own keys only; an EXPLICIT `k: undefined` source diverges,
+        // the explicit-undefined-is-absent stance). Everything else keeps
+        // the spread hint.
+        if (call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
+            const tProbe = probeLower(L, call.arguments[0]);
+            const sProbe = probeLower(L, call.arguments[1]);
+            // CHECKED-DYNAMIC target and source (the JS file-scope
+            // object-literal identity story): the runtime DOM copy — own
+            // members of the source land on the target, which returns.
+            if (tProbe?.type.kind === "dyn") {
+                const loc = locOf(call);
+                const target = L.lowerExpr(call.arguments[0]);
+                const source = L.coerceToExpected(L.lowerExpr(call.arguments[1]), DYN);
+                if (target.type.kind === "dyn" && source.type.kind === "dyn") {
+                    return { kind: "libCall", fn: "dyn.assign", args: [target, source], type: DYN, loc };
+                }
+            }
+            if (tProbe?.type.kind === "record" && sProbe?.type.kind === "record") {
+                const tShape = L.shapes.get(tProbe.type.shapeId);
+                const sShape = L.shapes.get(sProbe.type.shapeId);
+                const ok = tShape && sShape &&
+                    !tShape.tuple && !sShape.tuple &&
+                    !tShape.indexValue && !sShape.indexValue &&
+                    !shapeHasAccessorSlots(tShape) && !shapeHasAccessorSlots(sShape) &&
+                    sShape.fields.every((sf) => {
+                        const tf = tShape.fields.find((x) => x.name === sf.name);
+                        return tf !== undefined && typeEquals(tf.type, sf.type);
+                    });
+                if (ok) {
+                    const loc = locOf(call);
+                    const target = L.lowerExpr(call.arguments[0]);
+                    const source = L.lowerExpr(call.arguments[1]);
+                    if (target.type.kind === "record" && source.type.kind === "record") {
+                        const helper = recordAssignHelper(L, target.type.shapeId, source.type.shapeId, loc);
+                        return { kind: "call", callee: helper, args: [target, source], type: target.type, loc };
+                    }
+                }
+            }
+        }
         return null;
     }
     // Object.defineProperties over a CHECKED-DYNAMIC target (test/common's
@@ -5557,6 +5917,54 @@ function lowerObjectStaticCall(L, call, access) {
         }
         L.noLowering("Object.freeze of a possibly-aliased value", call, "freeze of a FRESH object/array literal (and of primitives) compiles — frozen-ness is unobservable there; an aliased target's later writes would need the runtime frozen bit");
     }
+    // `Object.hasOwn(r, k)` over a RECORD receiver: a record's own-key set
+    // is its declared field list, so membership is a compare chain against
+    // the field names (interned per shape). Undefined-armed (optional)
+    // fields answer by their runtime tag — the explicit-undefined-is-absent
+    // stance: an omitted optional field holds the undefined arm and reads
+    // as NOT own, exactly Node's absent key (an EXPLICIT `k: undefined`
+    // diverges — documented next to the child-env/JSON rule). Tuple,
+    // index-signature (overflow membership lives in the runtime map), and
+    // accessor-carrying shapes keep the SC2020 fence; non-record receivers
+    // do too.
+    if (member === "hasOwn" && call.arguments.length === 2 && !call.arguments.some((a) => ts.isSpreadElement(a))) {
+        const recvNode = call.arguments[0];
+        const keyNode = call.arguments[1];
+        const probed = probeLower(L, recvNode);
+        // A CHECKED-DYNAMIC receiver (the JS file-scope object-literal
+        // identity story): the runtime DOM probe — OBJ member presence, ARR
+        // index bounds, Node's ToObject TypeError on nullish.
+        if (probed?.type.kind === "dyn") {
+            const loc = locOf(call);
+            const receiver = L.lowerExpr(recvNode);
+            let key = L.lowerExpr(keyNode);
+            if (key.type.kind === "f64" || key.type.kind === "bool" || key.type.kind === "dyn") {
+                key = { kind: "toString", operand: key, type: STRING, loc: locOf(keyNode) };
+            }
+            if (key.type.kind !== "string")
+                return null;
+            return { kind: "libCall", fn: "dyn.hasOwn", args: [receiver, key], type: BOOL, loc };
+        }
+        if (probed?.type.kind !== "record")
+            return null;
+        const shape = L.shapes.get(probed.type.shapeId);
+        if (!shape || shape.tuple || shape.indexValue || shapeHasAccessorSlots(shape))
+            return null;
+        const loc = locOf(call);
+        const receiver = L.lowerExpr(recvNode);
+        if (receiver.type.kind !== "record")
+            return null; // probe/lower drift: keep the fence
+        let key = L.lowerExpr(keyNode);
+        // Number/boolean/dyn keys stringify — ToPropertyKey, the keyed-write
+        // path's rule; symbol and composite keys keep the fence.
+        if (key.type.kind === "f64" || key.type.kind === "bool" || key.type.kind === "dyn") {
+            key = { kind: "toString", operand: key, type: STRING, loc: locOf(keyNode) };
+        }
+        if (key.type.kind !== "string")
+            return null;
+        const helper = recordHasOwnHelper(L, receiver.type.shapeId, loc);
+        return { kind: "call", callee: helper, args: [receiver, key], type: BOOL, loc };
+    }
     if (member !== "keys" && member !== "values" && member !== "entries")
         return null;
     if (call.arguments.length !== 1 || ts.isSpreadElement(call.arguments[0]))
@@ -6109,6 +6517,29 @@ export function bindingGenericFnNodeOf(decl) {
     }
     return null;
 }
+/** The CONTEXTUAL twin of bindingGenericFnNodeOf: `const g: Mapper = (x)
+   * => x` where `type Mapper = <T>(x: T) => T` — the initializer declares
+   * no type parameters of its own, but the ANNOTATION's one call signature
+   * does, and the checker types the arrow's parameters by those (`x: T`).
+   * Such a binding monomorphizes exactly like `const g = <T>(x: T) => x`;
+   * bindingGenericFnInfoOf reads the type parameters off the annotation's
+   * signature. Null when the shape doesn't match (a concrete annotation, a
+   * generic arrow — the syntactic probe's case, an overloaded alias). */
+export function bindingContextualGenericFnNodeOf(L, decl) {
+    if (!ts.isIdentifier(decl.name) || decl.initializer === undefined || decl.type === undefined)
+        return null;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!(ts.isArrowFunction(init) || ts.isFunctionExpression(init)) ||
+        init.typeParameters !== undefined || init.body === undefined) {
+        return null;
+    }
+    const sigs = L.checker.getCallSignatures(L.typeOf(decl.name));
+    if (sigs.length !== 1 || sigs[0].getTypeParameters().length === 0)
+        return null;
+    return init;
+}
 /** The interned GenericFnInfo for one generic arrow/function-expression
    * binding initializer, with the supportability fences applied ONCE per
    * declaration: the binding must sit at module scope (the compiled
@@ -6150,11 +6581,29 @@ export function bindingGenericFnInfoOf(L, decl, fnNode) {
         L.unsupported("SC1090", decl.name, `generic function values in reassigned bindings (calls of '${name}' resolve statically against this initializer, so the binding must provably hold it — a const, or a let/var nothing in its declaring file writes)`);
     }
     const typeParams = [];
-    for (const tp of fnNode.typeParameters) {
-        const tpSym = L.checker.getSymbolAtLocation(tp.name);
-        if (!tpSym)
+    if (fnNode.typeParameters !== undefined) {
+        for (const tp of fnNode.typeParameters) {
+            const tpSym = L.checker.getSymbolAtLocation(tp.name);
+            if (!tpSym)
+                L.unsupported("SC1090", fnNode, "this function form");
+            typeParams.push(tpSym);
+        }
+    }
+    else {
+        // The CONTEXTUAL shape (bindingContextualGenericFnNodeOf): the type
+        // parameters live on the annotation's one call signature, and the
+        // checker types the initializer's parameters by them — the same
+        // symbols the instance bodies resolve through.
+        const sigs = L.checker.getCallSignatures(L.typeOf(decl.name));
+        const tps = sigs.length === 1 ? sigs[0].getTypeParameters() : [];
+        if (tps.length === 0)
             L.unsupported("SC1090", fnNode, "this function form");
-        typeParams.push(tpSym);
+        for (const tp of tps) {
+            const tpSym = tp.getSymbol();
+            if (!tpSym)
+                L.unsupported("SC1090", fnNode, "this function form");
+            typeParams.push(tpSym);
+        }
     }
     // Only NAME syntax is checkable here; optional/default/rest shapes are
     // computed per instantiation from the resolved signature — exactly
@@ -6181,6 +6630,53 @@ export function bindingGenericFnInfoOf(L, decl, fnNode) {
     }
     return info;
 }
+/** `const h = id` — a binding ALIASING a generic function (a top-level
+   * declaration, a registered generic binding, or another alias — resolved
+   * left to right in declaration order). The alias registers the SAME info
+   * under its own symbol, so calls (`h(3)`) and pinned values (`take(h)`)
+   * resolve exactly like the target's own name, and the binding itself has
+   * no runtime value (a generic function value cannot materialize). Claims
+   * only bindings whose OWN type still keeps type parameters — a
+   * concrete-annotated alias (`const h: (x: number) => number = id`) is a
+   * pinned VALUE, the existing lowerGenericFnValue story. Null when the
+   * shape doesn't match or the target isn't a registered generic; fences
+   * (reassignment, var redeclaration) report by name inside. */
+export function bindingGenericFnAliasInfoOf(L, decl) {
+    if (!ts.isIdentifier(decl.name) || decl.initializer === undefined)
+        return null;
+    let init = decl.initializer;
+    while (ts.isParenthesizedExpression(init))
+        init = init.expression;
+    if (!ts.isIdentifier(init))
+        return null;
+    const target = genericFnOf(L, init);
+    if (!target)
+        return null;
+    // A concrete annotation pins one signature — that value story
+    // (lowerGenericFnValue at the reference) stays untouched.
+    const ownSigs = L.checker.getCallSignatures(L.typeOf(decl.name));
+    if (ownSigs.length === 0 || !ownSigs.every((s) => s.getTypeParameters().length > 0))
+        return null;
+    const sym = L.checker.getSymbolAtLocation(decl.name);
+    if (!sym)
+        return null;
+    const existing = L.genericFnsBySymbol.get(sym);
+    if (existing)
+        return existing;
+    const name = decl.name.text;
+    const isConst = (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.Const) !== 0;
+    // The same holds-it-forever discipline as generic arrow bindings:
+    // calls through the alias resolve statically against the target, so
+    // nothing may ever rebind it (merged `var` redeclarations included).
+    const redeclared = L.checker
+        .declarationsOf(sym)
+        .some((d) => d !== decl && ts.isVariableDeclaration(d) && d.initializer !== undefined);
+    if (!isConst && (redeclared || !bindingNeverReassigned(L, sym, decl))) {
+        L.unsupported("SC1090", decl.name, `generic function values in reassigned bindings (calls of '${name}' resolve statically against this initializer, so the binding must provably hold it — a const, or a let/var nothing in its declaring file writes)`);
+    }
+    L.genericFnsBySymbol.set(sym, target);
+    return target;
+}
 /** Static resolution stands in for the receiver's runtime value, so an
    * object-literal generic-method receiver must provably HOLD the defining
    * literal: a direct read of a binding whose initializer IS that literal
@@ -6241,8 +6737,36 @@ export function lowerObjLitGenericMethodCall(L, call, access) {
     if (L.checker.declarationsOf(propSym).some((d) => d.parent !== undefined && (ts.isClassDeclaration(d.parent) || ts.isClassExpression(d.parent)))) {
         return null;
     }
+    // An INTERFACE-typed receiver over a class instance (`const r: Repo =
+    // new MemRepo(); r.get(...)` — the declaration is signature-only, but
+    // the receiver's exact class is statically proven and the binding
+    // kept the class representation, genericIfaceBindingKeepsClass): the
+    // call is a class generic-method call on that exact class. The
+    // receiver must LOWER as the class — a record-held value (a `let`, a
+    // produced value, a parameter) has already dropped it, and keeps the
+    // named fence below.
+    {
+        const exact = exactInstanceClassOf(L, access.expression);
+        const gfound = exact ? findGenericMethodOn(L, exact, name) : null;
+        if (gfound && ts.isIdentifier(access.expression)) {
+            const recv = L.lowerExpr(access.expression); // identifier reads are pure — no double evaluation
+            if (recv.type.kind === "object") {
+                return lowerClassGenericMethodCall(L, call, access, exact, gfound, recv);
+            }
+        }
+    }
     const found = objLitGenericFnNodeOf(L, propSym);
     if (!found) {
+        // Interface-declared generic methods dispatch statically, so the
+        // receiver's runtime class must be provable — name that discipline
+        // instead of the object-literal wording when the method lives on an
+        // interface.
+        const onInterface = L.checker
+            .declarationsOf(propSym)
+            .some((d) => d.parent !== undefined && ts.isInterfaceDeclaration(d.parent));
+        if (onInterface) {
+            L.unsupported("SC1090", call, `calls of the generic method '${name}' through this receiver (the interface declaration is signature-only and generic methods dispatch statically, so the receiver's runtime class must be provable — bind the receiver to a const initialized with its 'new' expression, e.g. 'const r: ${L.checker.typeToString(recvT)} = new C(...)')`);
+        }
         L.unsupported("SC1090", call, `calls of the generic method '${name}' with no defining object literal (the declaration is signature-only — only methods declared with a body in an object literal monomorphize)`);
     }
     requireObjLitGenericReceiver(L, call, access.expression, found.literal, name);