@kernlang/python 3.5.9-canary.220.1.c398cd95 → 4.0.1-canary.222.1.f06f1a51

package/dist/codegen-body-python.js

@@ -40,9 +40,10 @@
  *  threads a `indent` string. The propagation hoist embeds its own 4-space
  *  relative indent on the `return __k_tN` line; the wrapper prepends the
  *  surrounding indent so the post-emit result nests correctly. */
-import { applyTemplate, emitStringKeyArray, isPostfixMutationOperator, isSupportedAssignOperator, KERN_STDLIB_MODULES, lookupStdlib, needsArgParens, needsBinaryParens, parseExpression, parseKeys, suggestStdlibMethod, } from '@kernlang/core';
+import { applyTemplate, collectFreeIdentifierNames, emitStringKeyArray, instanceofRhsPythonType, instanceofRhsRejectReasonForName, isPostfixMutationOperator, isSupportedAssignOperator, KERN_STDLIB_MODULES, lookupStdlib, lowerJsClosureBodyToPython, needsArgParens, needsBinaryParens, parseExpression, parseKeys, suggestStdlibMethod, } from '@kernlang/core';
 import { buildPythonParamList } from './codegen-helpers.js';
-import { KERN_FMT_HELPER_PY, KERN_I32_HELPER_PY, KERN_PAIR_HELPERS_PY, KERN_TMOD_HELPER_PY, } from './core/expr/index.js';
+import { KERN_FMT_HELPER_PY, KERN_I32_HELPER_PY, KERN_JS_ARRAY_HELPERS_PY, KERN_JS_HELPER_PY, KERN_PAIR_HELPERS_PY, KERN_TMOD_HELPER_PY, } from './core/expr/index.js';
+import { isSharedPortableArrayMethod, isSharedPortableArrayProperty, lowerPortableArrayMethodPy, lowerPortableArrayPropertyPy, sharedPortableMethodRequiresPureReceiver, } from './core/expr/list-ops.js';
 import { mapTsTypeToPython } from './type-map.js';
 const INDENT_STEP = '    ';
 function freshCtx(options) {
@@ -51,6 +52,8 @@ function freshCtx(options) {
         imports: new Set(),
         helpers: new Set(),
         symbolMap: options?.symbolMap ?? {},
+        inClassBody: options?.inClassBody ?? false,
+        inConstructor: options?.inConstructor ?? false,
         shadowedSymbols: new Set(),
         localScopes: [],
         regexScopes: [],
@@ -60,7 +63,12 @@ function freshCtx(options) {
         tryDepth: 0,
         finallyDepth: 0,
         standaloneExpression: false,
+        coerceJsValues: options?.coerceJsValues ?? true,
         traceHooks: options?.traceHooks,
+        pendingHoists: [],
+        closureSeq: 0,
+        loopScopeIndexes: [],
+        loopLaterAssignFrames: [],
     };
 }
 /** PR-4 — Python helpers that normalize `each` pair-mode iteration sources.
@@ -151,6 +159,13 @@ export function emitNativeKernBodyPythonWithImports(handlerNode, options) {
     }
     try {
         const code = emitChildrenPy(handlerNode.children ?? [], ctx, '').join('\n');
+        // Slices 0+1 — a hoisted closure def left un-flushed means some statement
+        // emitter produced a block arrow without routing through emitChildrenPy's
+        // flush point. That would silently drop the def → NameError at runtime.
+        // Fail loud instead.
+        if (ctx.pendingHoists.length > 0) {
+            throw new Error('Internal codegen error: block-arrow closure def(s) were not flushed (a statement emitter bypassed the emitChildrenPy hoist point).');
+        }
         return { code, imports: ctx.imports, usedPropagation: ctx.usedPropagation, helpers: ctx.helpers };
     }
     finally {
@@ -192,15 +207,83 @@ function trailingCommentToPy(raw) {
         return `# ${raw.slice(2, -2).trim()}`.trimEnd();
     return `# ${raw}`.trimEnd();
 }
-function emitChildrenPy(children, ctx, indent, initialBindings = []) {
+/** Slice-2 fix — map each bare-identifier write target inside a loop body to the
+ *  LAST top-level child index whose subtree writes it. Recurses into nested
+ *  statements (if/else branches, nested loops, try bodies) but attributes every
+ *  write to the TOP-LEVEL child containing it (the granularity
+ *  `loopLaterAssignFrames.current` tracks). Member/index targets (`this.x`,
+ *  `a[i]`) are excluded — mutating a captured OBJECT is by-reference in both
+ *  languages and never pinned.
+ *
+ *  Covered write node types (the body-statement emitters that can rebind a bare
+ *  name): `assign` (its `target=` prop, INCLUDING the compound `op="+="`/`-=`/…
+ *  and postfix `op="++"`/`--` forms — all the same node type, distinguished only
+ *  by `op=`, all rebinding `target=`) and `set` (its `name=` prop, a bare-name
+ *  cell write). `let`/`cell` are DECLARATIONS, not reassignments, so they are
+ *  not scanned (the binding they create is the thing being pinned). */
+function collectLoopAssignLastIndexes(children) {
+    const last = new Map();
+    const scan = (node, topIdx) => {
+        if (node.type === 'assign') {
+            // `target=` is the bare name (or member/index) being rebound, regardless of
+            // `op=` (plain `=`, compound `+=`, or postfix `++`/`--`).
+            const target = String(node.props?.target ?? '');
+            if (target && !target.includes('.') && !target.includes('['))
+                last.set(target, topIdx);
+        }
+        else if (node.type === 'set') {
+            // `set name=… to=…` rebinds a bare-name cell; the target is `name=`.
+            const target = String(node.props?.name ?? '');
+            if (target && !target.includes('.') && !target.includes('['))
+                last.set(target, topIdx);
+        }
+        for (const child of node.children ?? [])
+            scan(child, topIdx);
+    };
+    for (let i = 0; i < children.length; i++)
+        scan(children[i], i);
+    return last;
+}
+function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody = false) {
     const lines = [];
     ctx.localScopes.push(new Map(initialBindings));
     ctx.regexScopes.push(new Map(initialBindings.map(([name]) => [name, null])));
     ctx.renameStack.push(new Map());
+    // Slice-2 loop-variable pinning. When this recursion is a loop BODY, record
+    // the just-pushed scope's index so `emitBlockClosurePy` can decide whether a
+    // captured name resolves at-or-inside the enclosing loop body (→ pin). Only
+    // loop bodies mark a scope here — if/else/try/branch/with bodies do not, so a
+    // closure inside an `if` that is itself inside a loop still pins via the
+    // outer loop's recorded index (the `if` body's own scope index is >= it).
+    if (isLoopBody)
+        ctx.loopScopeIndexes.push(ctx.localScopes.length - 1);
+    // Slice-2 fix — pre-scan this loop body for bare-name assign targets so the
+    // closure emitter can reject a pin whose binding is reassigned AFTER the
+    // closure-creating statement (see loopLaterAssignFrames doc).
+    const loopFrame = isLoopBody ? { assignLast: collectLoopAssignLastIndexes(children), current: -1 } : null;
+    if (loopFrame)
+        ctx.loopLaterAssignFrames.push(loopFrame);
+    // Slices 0+1 fix (agon review, claude 0.7) — isolate the hoist buffer per
+    // recursion level. A statement emitter that lowers a HEADER expression (an
+    // `if`/`while` condition, an `each`/`for` iterable, a `branch` scrutinee)
+    // pushes that expression's closure defs into the buffer BEFORE recursing
+    // into its body via this function. Without isolation, the body-level
+    // per-child flush below would steal those defs and splice them INSIDE the
+    // body — after the header line already referenced the def name (runtime
+    // NameError: `if __kern_closure_0(2):` with the def indented under it).
+    // Saving/clearing here means a header def survives untouched until the
+    // PARENT level's per-child flush, which splices it before the entire
+    // statement — defs bind once, so before-the-header placement is correct for
+    // every header position including `elif` chains (the def simply precedes
+    // the whole if/elif chain).
+    const outerHoists = ctx.pendingHoists;
+    ctx.pendingHoists = [];
     try {
         for (let i = 0; i < children.length; i++) {
             const child = children[i];
-            const trailStart = lines.length;
+            if (loopFrame)
+                loopFrame.current = i;
+            let trailStart = lines.length;
             if (child.type === 'comment') {
                 for (const line of emitCommentPy(child))
                     lines.push(`${indent}${line}`);
@@ -327,7 +410,11 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                     throw new Error("Propagation '?' is not allowed in `while cond=` — bind the call to a `let` first, then test the bound name.");
                 }
                 lines.push(`${indent}while ${emitPyExprCtx(condIR, ctx)}:`);
-                const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP);
+                // Slice-2: a `while` body is a loop body — per-iteration locals declared
+                // INSIDE it (JS re-binds block-scoped lets each iteration) must pin.
+                // The condition var, declared OUTSIDE, resolves below the loop scope and
+                // stays late-bound (by-reference, JS-parity-correct).
+                const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [], true);
                 if (inner.length === 0)
                     lines.push(`${indent}${INDENT_STEP}pass`);
                 for (const sl of inner)
@@ -463,7 +550,7 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                     const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [
                         [k, 'const'],
                         [v, 'const'],
-                    ]);
+                    ], true);
                     if (inner.length === 0 && !ctx.traceHooks?.eachIterNext)
                         lines.push(`${indent}${INDENT_STEP}pass`);
                     for (const sl of inner)
@@ -491,7 +578,7 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                         if (ctx.traceHooks?.eachIterNext) {
                             lines.push(`${indent}${INDENT_STEP}_kern_trace({"op": "iter-next", "binding": ${JSON.stringify(k)}, "value": ${k}})`);
                         }
-                        const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [[k, 'const']]);
+                        const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [[k, 'const']], true);
                         if (inner.length === 0 && !ctx.traceHooks?.eachIterNext)
                             lines.push(`${indent}${INDENT_STEP}pass`);
                         for (const sl of inner)
@@ -504,7 +591,7 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                         if (ctx.traceHooks?.eachIterNext) {
                             lines.push(`${indent}${INDENT_STEP}_kern_trace({"op": "iter-next", "binding": ${JSON.stringify(v)}, "value": ${v}})`);
                         }
-                        const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [[v, 'const']]);
+                        const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, [[v, 'const']], true);
                         if (inner.length === 0 && !ctx.traceHooks?.eachIterNext)
                             lines.push(`${indent}${INDENT_STEP}pass`);
                         for (const sl of inner)
@@ -552,7 +639,7 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                 if (ctx.traceHooks?.eachIterNext) {
                     lines.push(`${indent}${INDENT_STEP}_kern_trace({"op": "iter-next", "binding": ${JSON.stringify(primaryBindingPy)}, "value": ${primaryBindingPy}})`);
                 }
-                const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, initialBindings);
+                const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP, initialBindings, true);
                 // `pass` is needed only when the for-loop body would otherwise be empty:
                 //   - index-mode path emits NO assignment (direct destructuring), so an
                 //     empty children list leaves the loop bodyless → IndentationError.
@@ -575,6 +662,24 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
                 for (const line of emitBranchPy(child, ctx, indent))
                     lines.push(line);
             }
+            // Slices 0+1 — flush hoisted block-arrow closure defs. `emitLambdaPy`
+            // pushed each `def __kern_closure_N(...):` block into `ctx.pendingHoists`
+            // when it lowered a block arrow used by THIS child. Splice them in at the
+            // current indent IMMEDIATELY BEFORE the child's own lines so the def
+            // precedes its use — works at any nesting level because every nested
+            // emission funnels through emitChildrenPy. Bump `trailStart` past the
+            // spliced defs so the trailing-comment check below still measures only
+            // the child's own line count.
+            if (ctx.pendingHoists.length > 0) {
+                const hoistLines = [];
+                for (const def of ctx.pendingHoists) {
+                    for (const dl of def)
+                        hoistLines.push(`${indent}${dl}`);
+                }
+                lines.splice(trailStart, 0, ...hoistLines);
+                trailStart += hoistLines.length;
+                ctx.pendingHoists = [];
+            }
             // W1 — re-attach an inline same-line trailing comment (captured by the
             // migrator as `trailingComment=`) to the simple statement's last line,
             // converted to a Python `#` comment.
@@ -588,9 +693,18 @@ function emitChildrenPy(children, ctx, indent, initialBindings = []) {
         }
     }
     finally {
+        if (isLoopBody)
+            ctx.loopScopeIndexes.pop();
+        if (loopFrame)
+            ctx.loopLaterAssignFrames.pop();
         ctx.localScopes.pop();
         ctx.regexScopes.pop();
         ctx.renameStack.pop();
+        // Restore the parent level's hoist buffer (see the isolation comment at
+        // entry). Any defs THIS level's last child left behind are appended so the
+        // parent's flush (or the defensive end-of-body throw) still sees them —
+        // hoists are never silently dropped.
+        ctx.pendingHoists = outerHoists.concat(ctx.pendingHoists);
     }
     return lines;
 }
@@ -667,7 +781,7 @@ function emitRangeForPy(node, ctx, indent) {
     if (ctx.traceHooks?.forIterNext) {
         out.push(`${bodyIndent}_kern_trace({"op": "iter-next", "binding": ${JSON.stringify(name)}, "value": ${name}})`);
     }
-    const inner = emitChildrenPy(node.children ?? [], ctx, bodyIndent, [[name, 'const']]);
+    const inner = emitChildrenPy(node.children ?? [], ctx, bodyIndent, [[name, 'const']], true);
     if (inner.length === 0 && !ctx.traceHooks?.forIterNext)
         out.push(`${bodyIndent}pass`);
     for (const sl of inner)
@@ -1248,6 +1362,20 @@ function lookupLocalBinding(ctx, name) {
     }
     return undefined;
 }
+/** Slice-2 — the index into `ctx.localScopes` of the innermost scope that
+ *  binds `name`, or `null` if no scope binds it (an unresolved/host name).
+ *  Used by `emitBlockClosurePy` to decide loop-variable pinning: a captured
+ *  name pins IFF its binding index is at-or-inside the outermost enclosing
+ *  loop body (`>= ctx.loopScopeIndexes[0]`). Walks innermost→outermost so a
+ *  shadowing inner re-declaration wins over an outer binding of the same name,
+ *  matching the rename resolution the body emission uses. */
+function findBindingScopeIndex(ctx, name) {
+    for (let i = ctx.localScopes.length - 1; i >= 0; i--) {
+        if (ctx.localScopes[i].has(name))
+            return i;
+    }
+    return null;
+}
 function isAssignableTarget(node) {
     if (node.kind === 'ident')
         return true;
@@ -1556,9 +1684,13 @@ const NON_EXCEPTION_LITERAL_KINDS = new Set([
  *  `emitPyExprCtx` which threads the live ctx (and therefore the live
  *  imports set) end-to-end. */
 export function emitPyExpression(node, options) {
+    return emitPyExpressionWithImports(node, options).code;
+}
+export function emitPyExpressionWithImports(node, options) {
     const ctx = freshCtx(options);
     ctx.standaloneExpression = true;
-    return emitPyExprCtx(node, ctx);
+    const code = emitPyExprCtx(node, ctx);
+    return { code, imports: ctx.imports, helpers: ctx.helpers };
 }
 function emitPyExprCtx(node, ctx) {
     switch (node.kind) {
@@ -1578,7 +1710,13 @@ function emitPyExprCtx(node, ctx) {
         case 'nullLit':
             return 'None';
         case 'undefLit':
-            return 'None';
+            // Ground/React layer (no helper channel) keeps the pre-slice collapse to
+            // None; native bodies materialize the sentinel so `${undefined}` renders
+            // "undefined" (vs null's "null") and `?? `/`typeof` can distinguish it.
+            if (!ctx.coerceJsValues)
+                return 'None';
+            ctx.helpers.add(KERN_FMT_HELPER_PY);
+            return '_KERN_UNDEFINED';
         case 'regexLit':
             ctx.imports.add('re');
             return `__k_re.compile(${pyRegexPattern(node)}, ${pyRegexFlags(node.flags, { allowGlobal: true })})`;
@@ -1597,6 +1735,8 @@ function emitPyExprCtx(node, ctx) {
             // module names) pass through unchanged.
             if (ctx.shadowedSymbols.has(node.name))
                 return node.name;
+            if (ctx.inClassBody && node.name === 'super')
+                return 'super()';
             return ctx.symbolMap[node.name] ?? node.name;
         }
         case 'member':
@@ -1621,14 +1761,44 @@ function emitPyExprCtx(node, ctx) {
         }
         case 'await':
             return `await ${emitPyExprCtx(node.argument, ctx)}`;
-        case 'new':
-            return emitPyExprCtx(node.argument, ctx);
+        case 'new': {
+            // Host Error mapping (spec §1): `new Error(args)` → `Exception(args)` on
+            // Python, since `raise Error(...)` / `isinstance(x, Error)` would
+            // NameError (Python has no global `Error`). The mapping also covers
+            // `let e = new Error(x)` and `throw new Error(x)` (both flow through the
+            // `new` expression). `new TypeError(...)` is intentionally NOT mapped —
+            // Python has a native `TypeError`, so it emits as-is.
+            // TODO(kern): RangeError/SyntaxError/ReferenceError/EvalError/URIError
+            // have NO same-named Python builtins and emit as-is → runtime NameError;
+            // map or reject in the v2 builtin-errors slice. A user KERN class
+            // literally named `Error` would be shadowed by this mapping —
+            // registry-precedence hardening is also v2.
+            const arg = node.argument;
+            if (arg.kind === 'call' && arg.callee.kind === 'ident' && arg.callee.name === 'Error') {
+                const remapped = { ...arg, callee: { ...arg.callee, name: 'Exception' } };
+                return emitPyExprCtx(remapped, ctx);
+            }
+            // `new Error` WITHOUT parens is valid JS (≡ `new Error()`) and parses as
+            // a bare ident argument — remap it too, else it emits a bare `Error`
+            // NameError (agon review, claude/zai convergence).
+            if (arg.kind === 'ident' && arg.name === 'Error') {
+                return 'Exception()';
+            }
+            return emitPyExprCtx(arg, ctx);
+        }
         case 'typeAssert':
             return emitPyExprCtx(node.expression, ctx);
         case 'nonNull':
             return emitPyExprCtx(node.expression, ctx);
         case 'tmplLit': {
-            // Lower TS template literals to Python f-strings.
+            // Lower TS template literals to Python f-strings. In native bodies, wrap
+            // each interpolation in _kern_fmt so JS value→string coercion semantics
+            // (true→"true", null→"null", undefined→"undefined", 1.0→"1", arrays→
+            // comma-joined, objects→"[object Object]") are preserved. The helper-less
+            // Ground/React layer keeps the pre-slice raw f-string interpolation.
+            const coerce = ctx.coerceJsValues;
+            if (coerce)
+                ctx.helpers.add(KERN_FMT_HELPER_PY);
             let out = 'f"';
             for (let i = 0; i < node.quasis.length; i++) {
                 out += node.quasis[i]
@@ -1637,8 +1807,10 @@ function emitPyExprCtx(node, ctx) {
                     .replace(/\n/g, '\\n')
                     .replace(/\{/g, '{{')
                     .replace(/\}/g, '}}');
-                if (i < node.expressions.length)
-                    out += `{${emitPyExprCtx(node.expressions[i], ctx)}}`;
+                if (i < node.expressions.length) {
+                    const inner = emitPyExprCtx(node.expressions[i], ctx);
+                    out += coerce ? `{_kern_fmt(${inner})}` : `{${inner}}`;
+                }
             }
             out += '"';
             return out;
@@ -1669,11 +1841,58 @@ function emitPyExprCtx(node, ctx) {
             if (node.op === 'instanceof') {
                 // JS `a instanceof B` → Python `isinstance(a, B)`. Emitting `instanceof`
                 // verbatim would be a Python *syntax* error, so this lowering is
-                // mandatory (unlike raw host methods, which emit verbatim). The RHS
-                // class name emits as-is — e.g. `Error` stays `Error`, consistent with
-                // how host globals like `Date` already emit; KERN's portable surface is
-                // the stdlib namespace, not raw host constructors.
-                return `isinstance(${left}, ${right})`;
+                // mandatory (unlike raw host methods, which emit verbatim).
+                //
+                // RHS handling (spec §2, shared table in core/instanceof-rhs.ts):
+                //   - accepted host global → mapped Python type: `Array`→`list`,
+                //     `Error`→`Exception` (so `e instanceof Error` ≡
+                //     `isinstance(e, Exception)`, mirroring `new Error(...)` →
+                //     `Exception(...)`; Python `except Exception as e` + this check ≡
+                //     JS catch + `e instanceof Error` for KERN-thrown errors).
+                //   - rejected RHS (wrapper-parity trap / unsupported builtin /
+                //     non-type-name) → THROW fail-closed. This is defense in depth:
+                //     the eligibility gate already rejects these bodies, so this throw
+                //     can only fire on directly-built IR, never on gate-passed source —
+                //     gate and lowerer share core/instanceof-rhs.ts and cannot drift.
+                //   - any other ident/member RHS → emit as-is (user classes work; an
+                //     unknown name fails loud at Python runtime with NameError —
+                //     registry-precedence hardening is v2).
+                const rhs = node.right;
+                if (rhs.kind === 'ident') {
+                    const rejectReason = instanceofRhsRejectReasonForName(rhs.name);
+                    if (rejectReason !== null) {
+                        throw new Error(`instanceof RHS '${rhs.name}' has no Python lowering (${rejectReason}). ` +
+                            'JS primitive-wrapper / unmapped-builtin instanceof has no isinstance parity; ' +
+                            'this body is ineligible for native KERN.');
+                    }
+                    const mapped = instanceofRhsPythonType(rhs.name);
+                    if (mapped !== null)
+                        return `isinstance(${left}, ${mapped})`;
+                    return `isinstance(${left}, ${right})`;
+                }
+                if (rhs.kind === 'member') {
+                    return `isinstance(${left}, ${right})`;
+                }
+                throw new Error('instanceof RHS is not a type name (instanceof-rhs-not-a-type-name); ' +
+                    'only a class identifier or qualified member name can lower to isinstance().');
+            }
+            if (node.op === '+' && ctx.coerceJsValues) {
+                // JS `+` is overloaded: string concat if either operand is string-ish,
+                // numeric addition otherwise. Python has no implicit coercion, so we
+                // lower based on syntactic hints:
+                //  - If either operand is syntactically string-producing (strLit/tmplLit),
+                //    emit _kern_fmt(left) + _kern_fmt(right) for JS string concat.
+                //  - Otherwise (idents/calls/members/numbers — type unknown at emit time),
+                //    emit __kern_add(left, right) so numeric + stays additive and dynamic
+                //    string concat is coerced at runtime.
+                // The helper-less Ground/React layer skips this and falls through to the
+                // generic raw `+` path below (pre-slice behavior, zero regression).
+                ctx.helpers.add(KERN_FMT_HELPER_PY);
+                const isStr = (n) => n.kind === 'strLit' || n.kind === 'tmplLit';
+                if (isStr(node.left) || isStr(node.right)) {
+                    return `_kern_fmt(${left}) + _kern_fmt(${right})`;
+                }
+                return `__kern_add(${left}, ${right})`;
             }
             if (node.op === '??') {
                 // Slice 4c — nullish coalesce lowering. Two shapes:
@@ -1697,11 +1916,22 @@ function emitPyExprCtx(node, ctx) {
                 // Slice 4c (post-buddy-review) was the easy-win expansion after the
                 // 22.7% empirical-gate scan; this lifts the slice-2 `??` throw and
                 // adds an estimated +7% to native eligibility on Agon-AI bodies.
+                // Ground/React layer keeps the pre-slice None-only nullish test (no
+                // sentinel, no helper). Native bodies also exclude the undefined
+                // sentinel so `undefined ?? x` coalesces.
+                if (!ctx.coerceJsValues) {
+                    if (isReceiverChainPure(node.left)) {
+                        return `(${left} if ${left} is not None else ${right})`;
+                    }
+                    const tmp = `__k_nc${++ctx.gensymCounter}`;
+                    return `(${tmp} if (${tmp} := ${left}) is not None else ${right})`;
+                }
+                ctx.helpers.add(KERN_FMT_HELPER_PY);
                 if (isReceiverChainPure(node.left)) {
-                    return `(${left} if ${left} is not None else ${right})`;
+                    return `(${left} if (${left} is not None and ${left} is not _KERN_UNDEFINED) else ${right})`;
                 }
                 const tmp = `__k_nc${++ctx.gensymCounter}`;
-                return `(${tmp} if (${tmp} := ${left}) is not None else ${right})`;
+                return `(${tmp} if ((${tmp} := ${left}) is not None and ${tmp} is not _KERN_UNDEFINED) else ${right})`;
             }
             const forceLeft = needsComparisonChainParens(node.left, node.op);
             const forceRight = needsComparisonChainParens(node.right, node.op);
@@ -1805,6 +2035,21 @@ function emitPyTypeof(argument, ctx) {
     const value = emitPyExprCtx(argument, ctx);
     const wrapped = needsArgParens(argument) ? `(${value})` : value;
     const tmp = `__k_typeof${++ctx.gensymCounter}`;
+    // Native bodies: a runtime value holding the undefined sentinel reports
+    // "undefined" (JS `typeof undefined`), not "object". The walrus binds in the
+    // first test so the sentinel branch is checked before the None branch. The
+    // helper-less Ground layer never materializes the sentinel, so it keeps the
+    // pre-slice None-first form.
+    if (ctx.coerceJsValues) {
+        ctx.helpers.add(KERN_FMT_HELPER_PY);
+        return (`("undefined" if (${tmp} := ${wrapped}) is _KERN_UNDEFINED ` +
+            `else "object" if ${tmp} is None ` +
+            `else "boolean" if isinstance(${tmp}, bool) ` +
+            `else "number" if isinstance(${tmp}, (int, float)) ` +
+            `else "string" if isinstance(${tmp}, str) ` +
+            `else "function" if callable(${tmp}) ` +
+            `else "object")`);
+    }
     return (`("object" if (${tmp} := ${wrapped}) is None ` +
         `else "boolean" if isinstance(${tmp}, bool) ` +
         `else "number" if isinstance(${tmp}, (int, float)) ` +
@@ -1814,6 +2059,9 @@ function emitPyTypeof(argument, ctx) {
 }
 function emitLambdaPy(node, ctx) {
     const names = node.params.map((p) => p.name);
+    if (node.bodyBlock) {
+        return emitBlockClosurePy(node, names, ctx);
+    }
     const previous = new Set(ctx.shadowedSymbols);
     for (const name of names)
         ctx.shadowedSymbols.add(name);
@@ -1825,6 +2073,180 @@ function emitLambdaPy(node, ctx) {
         ctx.shadowedSymbols = previous;
     }
 }
+/** Slices 0+1 — lower a block-bodied arrow (`x => { ... }`) to a hoisted local
+ *  Python `def`. Pushes `def __kern_closure_N(params): <body>` into
+ *  `ctx.pendingHoists` (flushed by emitChildrenPy immediately before the
+ *  enclosing statement) and RETURNS the def name as the expression string, so
+ *  `let scale = (x) => {...}` lowers to `scale = __kern_closure_0` with the def
+ *  hoisted above it.
+ *
+ *  The closure body is lowered through `lowerJsClosureBodyToPython`, reusing
+ *  the class-path expression/condition callbacks:
+ *   - `lowerExpression(raw)` = `emitPyExprCtx(parseExpression(raw), ctx)` —
+ *     identical to every other native-body expression emit, so a captured
+ *     RENAMED outer variable resolves through `ctx` (the rename stack /
+ *     symbolMap) exactly as it does outside the closure.
+ *   - `lowerCondition(raw)` mirrors the class/native if-emitter, which lowers a
+ *     condition as the bare `emitPyExprCtx(parseExpression(cond), ctx)` (NO
+ *     js_truthy wrapper). Matching it EXACTLY means a condition inside a
+ *     closure lowers identically to the same condition outside one.
+ *
+ *  Closure PARAMS shadow outer renames while the body is lowered (same
+ *  `shadowedSymbols` save/restore as the expression-lambda branch) — params
+ *  must NOT be renamed, while captures of renamed outer vars still resolve
+ *  through ctx. The v1 gate (commit A) guarantees the lowering succeeds;
+ *  gate/lowerer drift (`ok:false`) is a loud bug. */
+function emitBlockClosurePy(node, names, ctx) {
+    const closureName = `__kern_closure_${ctx.closureSeq++}`;
+    const previous = new Set(ctx.shadowedSymbols);
+    for (const name of names)
+        ctx.shadowedSymbols.add(name);
+    try {
+        const lowered = lowerJsClosureBodyToPython(node.bodyBlock.raw, {
+            lowerExpression: (raw) => emitPyExprCtx(parseExpression(raw), ctx),
+            // Mirror the native/class if-emitter EXACTLY (bare expression, no
+            // js_truthy) so a condition inside the closure matches the same
+            // condition outside it.
+            lowerCondition: (raw) => emitPyExprCtx(parseExpression(raw), ctx),
+            // The closure's own params are def-locals, never `nonlocal`: a write to a
+            // param (`(x) => { x = x + 1 }`) must not be reported as a written FREE
+            // name. The lowerer excludes both params and block-locals.
+            paramNames: names,
+            // Bare write TARGETS resolve through the SAME rename machinery reads use
+            // — a write to a shadow-renamed capture must target the renamed binding
+            // (`__k_shadow_x_N = …`), not the outer one (probe-verified silent
+            // wrong-values without this). Params/block-locals are never renamed, so
+            // the resolver is identity for them.
+            lowerAssignTarget: (name) => resolveLocalRename(ctx, name),
+        });
+        if (!lowered.ok) {
+            // The commit-A gate already accepted this block, so a lowering failure
+            // here is gate/lowerer drift — surface it loudly.
+            throw new Error(`Internal codegen error: block-arrow closure passed the v1 gate but failed to lower (${lowered.reason ?? 'unknown'}).`);
+        }
+        // Slice-2 loop-variable pinning. JS closures capture variables BY
+        // REFERENCE; a binding created PER-ITERATION (an each/for loop var, or any
+        // let/const declared inside a loop body) is re-bound each iteration, so
+        // each closure sees its own iteration's value. A naive Python hoisted def
+        // late-binds → every closure sees the LAST value (the classic 0,1,2 vs
+        // 2,2,2 bug). FIX: pin such captures via a default arg
+        // (`def __kern_closure_N(p, x=x):`) — Python evaluates defaults at def
+        // time = the hoist point before the enclosing statement = exactly the
+        // per-iteration snapshot JS produces.
+        //
+        // RULE: pin a captured name IFF its binding resolves at-or-inside the
+        // OUTERMOST loop body enclosing the closure (scope index >=
+        // loopScopeIndexes[0]). A binding declared OUTSIDE every loop (a function
+        // param, an accumulator, a `while` condition var) resolves below that
+        // index and stays late-bound — JS sees its CURRENT value at call time, and
+        // Python late binding is already parity-correct for it. Over-pinning those
+        // would WRONGLY freeze a value JS does not freeze.
+        const pinParams = [];
+        // The user-facing names that got PINNED (per-iteration loop captures). A
+        // WRITTEN free name that is also pinned is unlowerable in v1 (the def-time
+        // pin freezes the value; a `nonlocal` write would target the wrong binding)
+        // — it throws `closure-pinned-write` below. Tracked here so the throw and
+        // the disjointness assertion can consult it.
+        const pinnedNames = new Set();
+        if (ctx.loopScopeIndexes.length > 0) {
+            const free = collectFreeIdentifierNames(node.bodyBlock.raw, names);
+            const outermostLoopScope = ctx.loopScopeIndexes[0];
+            // Alphabetical by user-facing name for deterministic emission order.
+            for (const name of [...free].sort()) {
+                const scopeIndex = findBindingScopeIndex(ctx, name);
+                if (scopeIndex === null || scopeIndex < outermostLoopScope)
+                    continue;
+                // Slice-2 fix (agon review, claude 0.7) — a pin FREEZES the value at
+                // def time, but JS captures by reference: if the pinned binding is
+                // REASSIGNED in a later sibling statement of any enclosing loop body,
+                // the JS closure sees the mutation and the frozen default does not
+                // (`let t = 0; fns.push(() => t); t = t + x` → JS [1,2], pinned
+                // Python [0,0]). Fail closed instead of emitting silent divergence.
+                // Assignments in a STRICTLY-LOWER top-level child (`< current`) run
+                // before the closure and are captured by the pin — those are fine. The
+                // `>=` (not `>`) rejects an assignment in the SAME top-level child as the
+                // closure too: within-child statement order is not tracked (the whole
+                // child shares one index), so a same-child closure+reassignment cannot be
+                // proven safe — fail closed beats the silent divergence (kimi 0.85).
+                for (const frame of ctx.loopLaterAssignFrames) {
+                    const lastAssign = frame.assignLast.get(name);
+                    if (lastAssign !== undefined && lastAssign >= frame.current) {
+                        throw new Error(`Closure captures loop-local '${name}' which is reassigned after the closure is created — ` +
+                            `the per-iteration pin would freeze a value JS does not freeze. ` +
+                            `Bind the final value to a fresh const before creating the closure (v1 limitation).`);
+                    }
+                }
+                // Resolve to the SAME Python name the body emission uses. A captured
+                // loop-body binding goes through the block-scope rename stack
+                // (`resolveLocalRename`) — identical to the `ident` emit path — so a
+                // shadow-renamed inner `x` pins as `__k_shadow_x_N=__k_shadow_x_N`.
+                // (symbolMap is param-only and never names a loop-body-scoped binding,
+                // so it is intentionally not consulted here.)
+                const renamed = resolveLocalRename(ctx, name);
+                // Defensive (agon review, claude 0.3 nit): a renamed pin equal to a
+                // closure param would emit `def f(p, p=p)` — a Python SyntaxError.
+                // Renames are __k_shadow_*/gensym forms, so this is theoretical; fail
+                // loud rather than emit invalid Python if it ever happens.
+                if (names.includes(renamed)) {
+                    throw new Error(`Closure parameter '${renamed}' collides with the rename of captured '${name}' — rename the parameter.`);
+                }
+                pinParams.push(`${renamed}=${renamed}`);
+                pinnedNames.add(name);
+            }
+        }
+        // Mutation v1 — free-variable WRITES (`nonlocal`). A bare write to a free
+        // capture (one that is neither a closure param nor a block-local — the
+        // lowerer already excluded those) needs a `nonlocal` declaration so Python
+        // rebinds the OUTER binding instead of creating a def-local shadow (without
+        // it: `UnboundLocalError` for read+write, or a silent dead local for
+        // write-only). Member/index writes never appear in `writtenFreeNames` —
+        // they mutate a captured object by reference and need no `nonlocal`.
+        //
+        // The eligibility≢lowerability gap (documented on the gate): a write to a
+        // PINNED per-iteration capture cannot be lowered. The def-time default-arg
+        // pin freezes the value, and a `nonlocal` on that name would rebind the
+        // enclosing loop-body binding — neither matches JS's per-iteration
+        // by-reference capture. The gate cannot see the enclosing loop from a
+        // single statement, so we fail closed LOUDLY here.
+        const nonlocalNames = [];
+        for (const name of [...lowered.writtenFreeNames].sort()) {
+            if (pinnedNames.has(name)) {
+                throw new Error(`Closure writes to per-iteration loop capture '${name}', which v1 cannot lower: ` +
+                    `mutation of a per-iteration loop capture needs cell-boxing (v2). ` +
+                    `Bind to an outer variable or restructure.`);
+            }
+            nonlocalNames.push(name);
+        }
+        // Council's riskiest-thing defensive assertion: a name cannot be both
+        // pinned (a per-iteration loop capture → default-arg) AND nonlocal (an
+        // outer free write). By construction they are disjoint — pinning requires
+        // the binding to resolve AT-OR-INSIDE the outermost loop, while a
+        // nonlocal-written name is precisely one that did NOT (the pinned case
+        // throws above). If this ever fires, the pin condition and the written-free
+        // classification have drifted — a DESIGN error, not a user error.
+        for (const name of nonlocalNames) {
+            if (pinnedNames.has(name)) {
+                throw new Error(`Internal codegen invariant violated: '${name}' is both pinned and nonlocal in closure ${closureName}.`);
+            }
+        }
+        const params = [...names, ...pinParams].join(', ');
+        // `lowered.lines` are body lines at 4-space indent (the lowerer's own
+        // convention); they nest directly under the `def` header. A `nonlocal` line
+        // (if any) is the def's FIRST body statement (Python requires it before any
+        // use of the name). The declared names are RENAME-RESOLVED — the body's
+        // write targets went through `lowerAssignTarget` (same resolver), so the
+        // nonlocal declaration, the writes, and the enclosing binding all agree on
+        // the renamed Python name for shadow-renamed captures.
+        const nonlocalLine = nonlocalNames.length > 0
+            ? [`    nonlocal ${nonlocalNames.map((n) => resolveLocalRename(ctx, n)).join(', ')}`]
+            : [];
+        ctx.pendingHoists.push([`def ${closureName}(${params}):`, ...nonlocalLine, ...lowered.lines]);
+        return closureName;
+    }
+    finally {
+        ctx.shadowedSymbols = previous;
+    }
+}
 function valueReferencesIdent(node, name) {
     switch (node.kind) {
         case 'ident':
@@ -1864,16 +2286,26 @@ function valueReferencesIdent(node, name) {
         case 'lambda':
             if (node.params.some((p) => p.name === name))
                 return false;
+            if (node.bodyBlock)
+                return rawBlockReferencesIdent(node.bodyBlock.raw, name);
             return valueReferencesIdent(node.body, name);
         default:
             return false;
     }
 }
+/** Conservative word-boundary check for an identifier inside a raw closure
+ *  block. Used when a block-bodied arrow (slices 0+1) has no expression `body`
+ *  to recurse. Over-matching is safe for the capture analyses that consume it. */
+function rawBlockReferencesIdent(raw, name) {
+    return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(raw);
+}
 function containsLambdaCapturingIdent(node, name) {
     switch (node.kind) {
         case 'lambda':
             if (node.params.some((p) => p.name === name))
                 return false;
+            if (node.bodyBlock)
+                return rawBlockReferencesIdent(node.bodyBlock.raw, name);
             return valueReferencesIdent(node.body, name);
         case 'member':
             return containsLambdaCapturingIdent(node.object, name);
@@ -1917,6 +2349,16 @@ function lowerChain(node, ctx) {
         const inner = obj.kind === 'member' || obj.kind === 'call' || obj.kind === 'index'
             ? lowerChain(obj, ctx)
             : { guard: null, expr: emitPyExprCtx(obj, ctx) };
+        // Portable Array *property* read (non-call `.length`) lowers through the
+        // SAME shared list-ops hook the route emitter uses, so `this.items.length`
+        // emits `len(self.items)` (not invalid `self.items.length`) — identical to
+        // a route handler's `arr.length` by construction. Only the trailing `.prop`
+        // link is rewritten; the accumulated optional-chain guard is left UNTOUCHED
+        // and still flows through `wrapGuardIfAny`, so `items?.length` stays
+        // `(len(items) if items is not None else None)`-shaped.
+        const linkExpr = isSharedPortableArrayProperty(node.property)
+            ? (lowerPortableArrayPropertyPy(inner.expr, node.property) ?? `${inner.expr}.${node.property}`)
+            : `${inner.expr}.${node.property}`;
         if (node.optional) {
             // The receiver expression names what we need to test. The expr names
             // the receiver twice (once in test, once in branch); reject when that
@@ -1926,9 +2368,9 @@ function lowerChain(node, ctx) {
                     'Bind the call/await result to a `let` first, then use `let.field?.next` on the bound name.');
             }
             const newGuard = inner.guard === null ? `${inner.expr} is not None` : `${inner.guard} and ${inner.expr} is not None`;
-            return { guard: newGuard, expr: `${inner.expr}.${node.property}` };
+            return { guard: newGuard, expr: linkExpr };
         }
-        return { guard: inner.guard, expr: `${inner.expr}.${node.property}` };
+        return { guard: inner.guard, expr: linkExpr };
     }
     if (node.kind === 'index') {
         const obj = node.object;
@@ -1964,6 +2406,23 @@ function lowerChain(node, ctx) {
     const stdlib = applyStdlibLoweringPython(node, ctx);
     if (stdlib !== null)
         return { guard: null, expr: stdlib };
+    // Lambda-bearing array methods (`map`/`filter`/`some`/`every`) lower to a
+    // call-by-name comprehension. Peeked BEFORE the portable-array shim because
+    // none of these four are in that shim's set; gating here keeps the two paths
+    // independent and lets a non-matching shape fall through unchanged.
+    const lambdaArray = lowerLambdaArrayCallPython(node, ctx);
+    if (lambdaArray !== null)
+        return { guard: null, expr: lambdaArray };
+    // Portable array methods (e.g. `arr.push(x)`) lower through the SAME shared
+    // helper the route emitter uses, so a class method's `this.items.push(x)`
+    // matches a route handler's `arr.push(x)` by construction (no per-path drift).
+    const portableArray = lowerPortableArrayCallPython(node, ctx);
+    if (portableArray !== null)
+        return { guard: null, expr: portableArray };
+    if (ctx.inConstructor && node.callee.kind === 'ident' && node.callee.name === 'super') {
+        const superArgs = node.args.map((arg) => emitPyExprCtx(arg, ctx)).join(', ');
+        return { guard: null, expr: `super().__init__(${superArgs})` };
+    }
     if (node.callee.kind === 'ident' && node.callee.name === 'String') {
         if (node.args.length !== 1) {
             throw new Error('String() portable coercion expects exactly one argument on Python target.');
@@ -1974,6 +2433,14 @@ function lowerChain(node, ctx) {
         ctx.helpers.add(KERN_FMT_HELPER_PY);
         return { guard: null, expr: `_kern_fmt(${arg})` };
     }
+    // Host Error mapping, call-without-new form: JS `Error("x")` (no `new`)
+    // constructs an error too — remap like `new Error(...)`, else it emits a
+    // bare `Error(...)` NameError on Python (agon review, kimi 0.7). The same
+    // documented user-class-named-Error shadowing edge applies (v2 hardening).
+    if (node.callee.kind === 'ident' && node.callee.name === 'Error') {
+        const errArgs = node.args.map((arg) => emitPyExprCtx(arg, ctx)).join(', ');
+        return { guard: null, expr: `Exception(${errArgs})` };
+    }
     const callee = node.callee;
     const inner = callee.kind === 'member' || callee.kind === 'call' || callee.kind === 'index'
         ? lowerChain(callee, ctx)
@@ -1981,6 +2448,393 @@ function lowerChain(node, ctx) {
     const args = node.args.map((a) => emitPyExprCtx(a, ctx)).join(', ');
     return { guard: inner.guard, expr: `${inner.expr}(${args})` };
 }
+/**
+ * Lower a portable Array *method call* (e.g. `arr.push(x)`) through the shared
+ * `list-ops` module, so a class-method body and a route handler lower the same
+ * portable subset to identical Python. Returns `null` — and the caller falls
+ * through to the generic call emission — for anything that is not a bare,
+ * non-optional member call of a shared portable method on a guard-free
+ * receiver. Mirrors the peek-then-emit shape of `lowerRegexCallPython`.
+ */
+function lowerPortableArrayCallPython(call, ctx) {
+    const callee = call.callee;
+    if (callee.kind !== 'member' || callee.optional)
+        return null;
+    // Gate on method name BEFORE emitting receiver/args, so a non-shared call
+    // falls through without any duplicated emission. Arity is NOT gated here —
+    // the shared `lowerPortableArrayMethodPy` validates the arg count per method
+    // (push/concat are single-arg, slice takes 0/1/2) and returns null for shapes
+    // it can't lower, so a malformed call falls through unchanged. A blanket
+    // `args.length !== 1` guard here would have wrongly blocked `slice()` /
+    // `slice(1, 3)` (a push-shaped assumption — see spec 3a).
+    if (!isSharedPortableArrayMethod(callee.property))
+        return null;
+    const recvNode = callee.object;
+    // Per-method purity contract (scalar-method sweep). Multi-eval / mutating
+    // methods (push/reverse/at/lastIndexOf) name the receiver more than once
+    // (`(recv.append(x) or len(recv))`, `(recv.reverse() or recv)`), so a
+    // side-effectful receiver — `makeBag().items.push(x)`, `bags[idx()].reverse()`
+    // — would run those effects twice on Python and break JS parity; lower only a
+    // provably-pure receiver for those. Single-eval methods
+    // (slice/includes/indexOf/join/flat/concat/fill) name the receiver once, so they
+    // accept an impure receiver — the old blanket `isReceiverChainPure` guard
+    // wrongly skipped `makeBox().items.slice(1)` (the prior agon-review 0.97
+    // finding). The optional-chain guard below still applies to ALL methods.
+    if (sharedPortableMethodRequiresPureReceiver(callee.property) && !isReceiverChainPure(recvNode))
+        return null;
+    const recv = recvNode.kind === 'member' || recvNode.kind === 'call' || recvNode.kind === 'index'
+        ? lowerChain(recvNode, ctx)
+        : { guard: null, expr: emitPyExprCtx(recvNode, ctx) };
+    // A pure receiver can still be an optional chain (`a?.b`), which carries a
+    // None-guard the flat shim can't honor — fall through for those too.
+    if (recv.guard !== null)
+        return null;
+    const args = call.args.map((a) => (callee.property === 'fill' ? emitPyArrayFillArg(a, ctx) : emitPyExprCtx(a, ctx)));
+    const lowered = lowerPortableArrayMethodPy(recv.expr, callee.property, args);
+    if (lowered !== null && callee.property === 'fill') {
+        ctx.helpers.add(KERN_JS_ARRAY_HELPERS_PY);
+    }
+    return lowered;
+}
+function emitPyArrayFillArg(node, ctx) {
+    if (node.kind === 'undefLit')
+        return '_KERN_UNDEFINED';
+    return emitPyExprCtx(node, ctx);
+}
+/** Methods this peek lowers to a call-by-name comprehension. `reduce`/
+ *  `reduceRight` share the call-by-name callback resolution but lower to
+ *  `functools.reduce` (a different arg-count/arity contract), so they live in
+ *  `REDUCE_ARRAY_METHODS` and route through `lowerReduceArrayCallPython`.
+ *  `sort`-with-comparator remains DEFERRED (see slice report). */
+const LAMBDA_ARRAY_METHODS = new Set([
+    'map',
+    'filter',
+    'some',
+    'every',
+    // find-family + flatMap: same call-by-name comprehension architecture as
+    // map/filter (callback 1 or 2 params; the 2-param form binds the index via
+    // enumerate). The find-family wraps the predicate in `js_truthy`.
+    'find',
+    'findIndex',
+    'findLast',
+    'findLastIndex',
+    'flatMap',
+]);
+/** reduce/reduceRight take a callback of EXACTLY 2 params (acc, cur) and the
+ *  CALL itself carries 1 arg (cb) or 2 (cb, seed) — a different arg-count and
+ *  callback-arity contract than the enumerate-comprehension methods above, so
+ *  they are dispatched on their own path inside `lowerLambdaArrayCallPython`. */
+const REDUCE_ARRAY_METHODS = new Set(['reduce', 'reduceRight']);
+/**
+ * Lower a lambda-bearing Array method call (`recv.map(cb)` / `.filter` / `.some`
+ * / `.every`) on the class/native-body Python path to a call-by-name
+ * comprehension. Returns `null` — and the caller falls through to the generic
+ * call emission — for any shape this peek does not own. Peeked at the same
+ * dispatch point as `lowerPortableArrayCallPython` (these four methods are NOT
+ * in that shim's set).
+ *
+ * GATE (all required): a non-optional `member` callee, method ∈
+ * {map,filter,some,every}, exactly one call arg, and that arg is a `lambda`
+ * (expression- or block-bodied) OR a bare `ident`.
+ *
+ * Callback shapes resolved to a Python NAME `cb`:
+ *   - block lambda  → `emitPyExprCtx` returns the hoisted `def __kern_closure_N`
+ *                     name (closures v1), and the def is pushed into
+ *                     `ctx.pendingHoists` (flushed by emitChildrenPy before the
+ *                     enclosing statement).
+ *   - expr  lambda  → emit `lambda x: <expr>`, hoist ONE assignment
+ *                     `__kern_cb_N = <lambda>` into the SAME `ctx.pendingHoists`
+ *                     buffer; `cb` = `__kern_cb_N`.
+ *   - bare ident    → the rename-resolved identifier as-is. Arity is unknown for
+ *                     a named callback, so it is always called single-arg. JS
+ *                     would pass `(el, idx, arr)`; a named callback that reads a
+ *                     2nd/3rd param diverges — an ACCEPTED edge for this slice.
+ *
+ * MEMBER-EXPRESSION callbacks (`this.items.map(this.fmt)`) FALL THROUGH verbatim
+ * (the arg is a `member`, not `lambda`/`ident`, so the gate rejects it). This is
+ * deliberate: JS `.map(this.fmt)` passes the method UNBOUND (`this` is undefined
+ * inside it), so the TS target is already broken for such code. Lowering it on
+ * Python would create works-on-Python / breaks-on-TS anti-parity; until KERN
+ * defines a bound-method story there is nothing to be parity-correct WITH.
+ *
+ * TRUTHINESS: filter/some/every wrap the predicate result in `js_truthy(...)`.
+ * This is JS-CORRECT — JS keeps `[]`/`{}` truthy while bare Python drops them.
+ * Two VERIFIED pre-existing divergences are intentionally NOT fixed here:
+ *   (1) the ROUTE path's filter/find-family predicates are BARE (`if ${body}`,
+ *       core/expr/index.ts ~:294) — a pre-existing route truthiness bug, a
+ *       follow-up for the deferral-sweep slice;
+ *   (2) the class path's `if cond=` lowering is bare (no js_truthy wrapper) — a
+ *       separate follow-up.
+ * `js_truthy` here matches JS semantics for the lambda-array predicates only.
+ */
+function lowerLambdaArrayCallPython(call, ctx) {
+    // SCOPE GATE (do not remove). This lowering is for the class/native-body
+    // statement path (`emitNativeKernBodyPythonWithImports`, standaloneExpression
+    // = false). The standalone-expression entry point (`emitPyExpression`) is the
+    // Ground/React declarative + expression-unit surface; it emits array methods
+    // VERBATIM (e.g. `values.filter(lambda value: ...)`) by design, so do NOT
+    // intercept there. The FastAPI ROUTE path lowers `.map`/`.filter` through a
+    // SEPARATE string-rewrite (`core/expr` `rewriteExpr`/`lowerJsArrayMethods`),
+    // never this IR `lowerChain` peek, so routes are untouched.
+    if (ctx.standaloneExpression)
+        return null;
+    const callee = call.callee;
+    if (callee.kind !== 'member' || callee.optional)
+        return null;
+    const method = callee.property;
+    const isReduce = REDUCE_ARRAY_METHODS.has(method);
+    if (!LAMBDA_ARRAY_METHODS.has(method) && !isReduce)
+        return null;
+    // reduce/reduceRight have a DISTINCT contract (callback EXACTLY 2 params; the
+    // call carries 1 arg [cb] or 2 [cb, seed]) and lower to `functools.reduce`,
+    // not a comprehension. Handle them on their own path before the shared
+    // enumerate-comprehension machinery below. `callee.object` is the receiver.
+    if (isReduce)
+        return lowerReduceArrayCallPython(call, callee.object, method, ctx);
+    if (call.args.length !== 1)
+        return null;
+    const arg = call.args[0];
+    if (arg.kind !== 'lambda' && arg.kind !== 'ident')
+        return null;
+    // Resolve the callback to a NAME. For a lambda the arg arity decides the
+    // comprehension form (enumerate when 2 params); a bare ident is arity-unknown
+    // and always called single-arg (documented divergence above).
+    let cb;
+    let twoArity = false;
+    if (arg.kind === 'lambda') {
+        // The enumerate comprehension only supplies (el, i); a callback declaring a
+        // 3rd param (`(el, i, arr) => …`) would be DEFINED with 3 params but CALLED
+        // with 2 → runtime TypeError. Fall through verbatim (the pre-slice status quo
+        // for that shape) rather than emit a broken lowering.
+        if (arg.params.length > 2)
+            return null;
+        twoArity = arg.params.length >= 2;
+        const emitted = emitLambdaPy(arg, ctx);
+        if (arg.bodyBlock) {
+            // Block lambda → `emitLambdaPy` already pushed the hoisted def and
+            // returned its bare name; use it directly as the callback name.
+            cb = emitted;
+        }
+        else {
+            // Expression lambda → `emitted` is a `lambda x: <expr>`. Hoist ONE
+            // assignment into the SAME buffer as closure defs (flushed before the
+            // enclosing statement) and call it by name, so the comprehension names
+            // the callback exactly once.
+            cb = `__kern_cb_${ctx.closureSeq++}`;
+            ctx.pendingHoists.push([`${cb} = ${emitted}`]);
+        }
+    }
+    else {
+        // Bare LOCAL ident callback (`let f = …; recv.map(f)`). Emit through the
+        // ident path so a renamed binding resolves to its Python name.
+        cb = emitPyExprCtx(arg, ctx);
+    }
+    // Receiver: lowered ONCE. Every template below names `recv` EXACTLY ONCE, so
+    // there is NO purity gate here (deliberate contrast with the multi-eval
+    // list-ops methods, which DO gate — see `lowerPortableArrayCallPython`).
+    // FUTURE READER: do not add a redundant `isReceiverChainPure` gate; the
+    // single-eval property is what makes M6 (`this.bump().map(...)` runs bump()
+    // exactly once) correct.
+    const recvNode = callee.object;
+    const recv = recvNode.kind === 'member' || recvNode.kind === 'call' || recvNode.kind === 'index'
+        ? lowerChain(recvNode, ctx)
+        : { guard: null, expr: emitPyExprCtx(recvNode, ctx) };
+    // An optional-chain receiver (`a?.b`) carries a None-guard the comprehension
+    // can't honor — fall through unchanged for those.
+    if (recv.guard !== null)
+        return null;
+    // A compound receiver (a ternary `xs if c else ys`, a binary expression)
+    // dropped bare into a generator head parses WRONG: Python reads the `if`
+    // as the comprehension filter (`for el in xs if c else ys` → SyntaxError) —
+    // agon review, agy 1.0. Call-arg positions (`enumerate(recv)`) are immune;
+    // the bare `for … in recv` heads and `recv[::-1]` are not. Space-heuristic
+    // parens: atoms (`self.items`, `makeBox().items`, `[1, 2]`?) — note a
+    // bracketed literal contains ', ' but leading `[`/`(` already self-delimits;
+    // anything else with top-level spaces gets wrapped. Parens are never wrong,
+    // the heuristic only preserves byte-identical output for the common shapes.
+    const recvExpr = parenthesizeIterable(recv.expr);
+    // Hygienic loop vars, fresh per call.
+    const seq = ctx.gensymCounter++;
+    const el = `__kern_el_${seq}`;
+    const ix = `__kern_ix_${seq}`;
+    const callCb = twoArity ? `${cb}(${el}, ${ix})` : `${cb}(${el})`;
+    const head = twoArity ? `for ${ix}, ${el} in enumerate(${recvExpr})` : `for ${el} in ${recvExpr}`;
+    if (method === 'map') {
+        return `[${callCb} ${head}]`;
+    }
+    if (method === 'flatMap') {
+        // map, then flatten ONE level — JS flatMap only flattens arrays, so a
+        // scalar/string callback result is appended as a single element. The
+        // callback is bound to a fresh `__kern_r_N` via a one-element `for`, so it
+        // is called EXACTLY ONCE per element. This is deliberately BETTER than the
+        // FastAPI route's body-substitution lowering (core/expr/index.ts ~:336),
+        // which textually re-emits the callback body twice (`__x` substituted in
+        // both the isinstance test and the fallback) and double-evaluates a
+        // side-effecting callback — a tracked route follow-up. flatMap has no
+        // predicate, so NO js_truthy here.
+        const r = `__kern_r_${seq}`;
+        const y = `__kern_y_${seq}`;
+        return `[${y} ${head} for ${r} in [${callCb}] for ${y} in (${r} if isinstance(${r}, list) else [${r}])]`;
+    }
+    // filter + find-family predicates wrap in `js_truthy` (JS-correct; map/flatMap
+    // do not need it). The helper lands once via the helper Set.
+    ctx.helpers.add(KERN_JS_HELPER_PY);
+    if (method === 'filter') {
+        return `[${el} ${head} if js_truthy(${callCb})]`;
+    }
+    if (method === 'some') {
+        return `any(js_truthy(${callCb}) ${head})`;
+    }
+    if (method === 'every') {
+        return `all(js_truthy(${callCb}) ${head})`;
+    }
+    // find-family — `next((<gen>), <miss>)` never raises. find/findLast yield the
+    // ELEMENT (miss → None); findIndex/findLastIndex yield the INDEX (miss → -1).
+    // The *Last variants scan a reversed view; with a 2-param callback the index
+    // must come from enumerate, so they reverse `list(enumerate(recv))` (mirrors
+    // the route's findLast/findLastIndex shape).
+    if (method === 'find') {
+        return `next((${el} ${head} if js_truthy(${callCb})), None)`;
+    }
+    if (method === 'findIndex') {
+        // The index is always bound here, so iterate enumerate(recv) even for a
+        // 1-param callback (which is called single-arg on the element).
+        const enumHead = `for ${ix}, ${el} in enumerate(${recvExpr})`;
+        return `next((${ix} ${enumHead} if js_truthy(${callCb})), -1)`;
+    }
+    if (method === 'findLast') {
+        const revHead = twoArity
+            ? `for ${ix}, ${el} in reversed(list(enumerate(${recvExpr})))`
+            : `for ${el} in reversed(${recvExpr})`;
+        return `next((${el} ${revHead} if js_truthy(${callCb})), None)`;
+    }
+    // method === 'findLastIndex'
+    const revIndexHead = `for ${ix}, ${el} in reversed(list(enumerate(${recvExpr})))`;
+    return `next((${ix} ${revIndexHead} if js_truthy(${callCb})), -1)`;
+}
+/** Lower `recv.reduce(cb)` / `.reduce(cb, seed)` / `.reduceRight(...)` on the
+ *  class/native-body Python path to `functools.reduce`. Returns `null` (caller
+ *  falls through to verbatim emission) for any shape this peek does not own.
+ *
+ *  CONTRACT (all required): a non-optional `member` callee already checked by
+ *  the caller; the call carries 1 arg (cb) or 2 (cb, seed); the callback is a
+ *  `lambda` with EXACTLY 2 params (acc, cur) OR a bare `ident` (arity unknown —
+ *  accepted, called with two args by functools.reduce). A 1- or 3+-param lambda
+ *  callback (e.g. an idx-reading `(a, c, i) =>`) FALLS THROUGH verbatim (status
+ *  quo) rather than emit a callback functools.reduce would call with the wrong
+ *  arity.
+ *
+ *  JS `reduce((acc, cur) => …)` arg order == `functools.reduce(fn(acc, cur), …)`,
+ *  so NO adaptation is needed (asserted by the order-sensitive FR7 fixture).
+ *  reduceRight is the same callback over the reversed sequence (`recv[::-1]`).
+ *
+ *  PARITY NOTE: JS `[].reduce(cb)` (no seed, empty array) throws TypeError;
+ *  Python `functools.reduce(cb, [])` raises TypeError too — same failure mode,
+ *  documented parity (not a divergence).
+ *
+ *  IMPORT: `functools` is registered via `ctx.imports.add('functools')`, which
+ *  the fn/method generators render as `import functools as __k_functools` (the
+ *  same alias convention as `re` → `__k_re`); the template names
+ *  `__k_functools.reduce`. The Set dedupes, so the import lands exactly once per
+ *  body. (The FastAPI route path uses a SEPARATE imports channel that emits a
+ *  bare `import functools`; this class path is untouched by that.) */
+function lowerReduceArrayCallPython(call, recvNode, method, ctx) {
+    if (call.args.length !== 1 && call.args.length !== 2)
+        return null;
+    const cbArg = call.args[0];
+    if (cbArg.kind !== 'lambda' && cbArg.kind !== 'ident')
+        return null;
+    // Member-expression callbacks fall through verbatim (same unbound-this policy
+    // as the comprehension methods) — the gate above already rejects them.
+    let cb;
+    if (cbArg.kind === 'lambda') {
+        // EXACTLY 2 params (acc, cur). A 1-param or 3+-param (idx-reading) callback
+        // would be mis-called by functools.reduce — fall through verbatim.
+        if (cbArg.params.length !== 2)
+            return null;
+        const emitted = emitLambdaPy(cbArg, ctx);
+        if (cbArg.bodyBlock) {
+            // Block lambda → hoisted def name from emitLambdaPy; use it directly.
+            cb = emitted;
+        }
+        else {
+            // Expression lambda → hoist `__kern_cb_N = lambda a, c: <expr>` and pass
+            // the name, so functools.reduce names the callback exactly once.
+            cb = `__kern_cb_${ctx.closureSeq++}`;
+            ctx.pendingHoists.push([`${cb} = ${emitted}`]);
+        }
+    }
+    else {
+        // Bare LOCAL ident callback — resolve through the ident path.
+        cb = emitPyExprCtx(cbArg, ctx);
+    }
+    // Receiver: lowered ONCE (same single-eval property as the comprehension
+    // methods — no purity gate). `recvNode` is the caller's already-narrowed
+    // `callee.object`.
+    const recv = recvNode.kind === 'member' || recvNode.kind === 'call' || recvNode.kind === 'index'
+        ? lowerChain(recvNode, ctx)
+        : { guard: null, expr: emitPyExprCtx(recvNode, ctx) };
+    if (recv.guard !== null)
+        return null;
+    // reduceRight reverses the sequence; reduce uses it as-is. The slice binds
+    // TIGHTER than ternary/binary receivers (`xs if c else ys[::-1]` slices only
+    // `ys` — agon review, agy 1.0), so the receiver is parenthesized when
+    // compound. The plain-reduce position is a call argument (self-delimiting),
+    // but wrap uniformly so both methods agree on the receiver text.
+    const recvExpr = parenthesizeIterable(recv.expr);
+    const seq = method === 'reduceRight' ? `${recvExpr}[::-1]` : recvExpr;
+    ctx.imports.add('functools');
+    if (call.args.length === 2) {
+        const seed = emitPyExprCtx(call.args[1], ctx);
+        return `__k_functools.reduce(${cb}, ${seq}, ${seed})`;
+    }
+    return `__k_functools.reduce(${cb}, ${seq})`;
+}
+/** Parenthesize a lowered receiver for generator-head (`for el in <recv>`) and
+ *  slice (`<recv>[::-1]`) positions, where a compound expression parses wrong
+ *  (a bare ternary's `if` reads as the comprehension filter — SyntaxError; a
+ *  slice binds only the rightmost operand). Space heuristic: an expression
+ *  with no top-level spaces is an atom/chain (`self.items`, `makeBox().items`,
+ *  `xs[1:]`) and stays bare (byte-identical to pre-fix output); one that
+ *  starts with a self-delimiting bracket also stays bare; anything else wraps.
+ *  Parens are never semantically wrong — the heuristic only preserves
+ *  idiomatic output for the common shapes. */
+function parenthesizeIterable(expr) {
+    if (!expr.includes(' '))
+        return expr;
+    // A leading bracket is only self-delimiting if it CLOSES at the very end
+    // (`[1, 2, 3]` yes; `[1] if c else [2]` no — same opener, not enclosing).
+    const open = expr[0];
+    const close = open === '[' ? ']' : open === '(' ? ')' : open === '{' ? '}' : null;
+    if (close !== null && expr[expr.length - 1] === close) {
+        let depth = 0;
+        let quote = null;
+        for (let i = 0; i < expr.length; i++) {
+            const ch = expr[i];
+            if (quote) {
+                if (ch === '\\')
+                    i++;
+                else if (ch === quote)
+                    quote = null;
+                continue;
+            }
+            if (ch === '"' || ch === "'")
+                quote = ch;
+            else if (ch === '[' || ch === '(' || ch === '{')
+                depth++;
+            else if (ch === ']' || ch === ')' || ch === '}') {
+                depth--;
+                // Depth returns to 0 before the end → the leading bracket does NOT
+                // enclose the whole expression.
+                if (depth === 0 && i < expr.length - 1)
+                    return `(${expr})`;
+            }
+        }
+        if (depth === 0)
+            return expr;
+    }
+    return `(${expr})`;
+}
 function lowerRegexCallPython(call, ctx) {
     const callee = call.callee;
     if (callee.kind !== 'member')
@@ -2180,6 +3034,12 @@ function lowerListLambdaPython(moduleName, methodName, call, ctx) {
     if (callback.params.length !== 1) {
         throw new Error(`List.${methodName} expects a one-parameter lambda on the Python target.`);
     }
+    // Block-bodied arrow callback: the comprehension lowering only handles an
+    // expression `body`. Fall through (null) so the lambda routes through the
+    // default call path → `emitLambdaPy` (which fails closed in commit A and
+    // hoists a local def in commit B).
+    if (!callback.body)
+        return null;
     const name = callback.params[0].name;
     const previous = new Set(ctx.shadowedSymbols);
     ctx.shadowedSymbols.add(name);
@@ -2260,7 +3120,10 @@ export function lowerBitwiseAndModuloAST(node) {
                 args: node.args.map(lowerBitwiseAndModuloAST),
             };
         case 'lambda':
-            return { ...node, body: lowerBitwiseAndModuloAST(node.body) };
+            // Block-bodied arrows carry raw text, not an expression `body`. The raw
+            // is re-parsed and lowered during closure emission (commit B), so leave
+            // it untouched here.
+            return node.bodyBlock ? node : { ...node, body: lowerBitwiseAndModuloAST(node.body) };
         case 'spread':
             return { ...node, argument: lowerBitwiseAndModuloAST(node.argument) };
         case 'await':
@@ -2337,7 +3200,10 @@ export function registerHelpers(node, ctx) {
             registerHelpers(node.index, ctx);
             break;
         case 'lambda':
-            registerHelpers(node.body, ctx);
+            // Block-bodied arrows have no expression `body`; helpers referenced by a
+            // block body are registered during closure emission (commit B).
+            if (node.body)
+                registerHelpers(node.body, ctx);
             break;
         case 'spread':
             registerHelpers(node.argument, ctx);