@kernlang/python 4.1.1-canary.228.1.41c150f2 → 4.1.1-canary.232.1.c7f7511c

package/dist/codegen-body-python.js

@@ -40,7 +40,7 @@
  *  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, assertNoDecimalOperator, classifyRegexLiteralIndexReadFailClose, classifyRegexLiteralMemberReadFailClose, decimalBareConstructionFailMessage, emitStringKeyArray, expandRegexIFold, instanceofRhsPythonType, instanceofRhsRejectReasonForName, isHostNamespaceRoot, isPostfixMutationOperator, isSupportedAssignOperator, isZeroWidthCapableRegex, KERN_DECIMAL_OPS_HELPER_PY, KERN_STDLIB_MODULES, KERN_TEXT_OPS_HELPER_PY, lookupStdlibCall, lookupStdlibProperty, lowerRegexAnchorsPython, lowerRegexNamedGroupsPython, needsArgParens, needsBinaryParens, normalizeRegexClasses, parseExpression, parseKeys, REGEX_EXEC_FAILCLOSE, REGEX_HOST_REGEXP_FAILCLOSE, REGEX_MATCHALL_NO_G_FAILCLOSE, REGEX_NONLITERAL_FAILCLOSE, REGEX_REPLACE_NONLITERAL_REPL_FAILCLOSE, REGEX_REPLACEALL_NO_G_FAILCLOSE, REGEX_SPLIT_LIMIT_FAILCLOSE, REGEX_SPLIT_ZEROWIDTH_FAILCLOSE, REGEX_TEST_G_FAILCLOSE, regexAstralFailMessage, regexCaptureMeta, regexIFoldFailMessage, regexLiteralReceiverIR, regexMethodRegexArgIdent, scanRegexAstral, suggestStdlibMethod, translateReplStringToPython, unmappedHostNamespaceMessage, unwrapTransparentReceiverIR, validateDecimalConstructionArg, validateDecimalDivModArgs, validateDecimalOperands, validateDecimalPowArgs, validateRegexNamedGroupsPortable, } from '@kernlang/core';
+import { applyTemplate, assertNoDecimalOperator, classifyRegexLiteralIndexReadFailClose, classifyRegexLiteralMemberReadFailClose, decimalBareConstructionFailMessage, emitStringKeyArray, expandRegexIFold, instanceofRhsPythonType, instanceofRhsRejectReasonForName, isHostNamespaceRoot, isParenthesized, isPostfixMutationOperator, isSafeIntegerLiteralIndex, isSupportedAssignOperator, isZeroWidthCapableRegex, KERN_DECIMAL_OPS_HELPER_PY, KERN_STDLIB_MODULES, KERN_TEXT_OPS_HELPER_PY, lookupStdlibCall, lookupStdlibProperty, lowerRegexAnchorsPython, lowerRegexNamedGroupsPython, needsArgParens, needsBinaryParens, normalizeRegexClasses, parseExpression, parseKeys, REGEX_EXEC_FAILCLOSE, REGEX_HOST_REGEXP_FAILCLOSE, REGEX_MATCHALL_NO_G_FAILCLOSE, REGEX_NONLITERAL_FAILCLOSE, REGEX_REPLACE_NONLITERAL_REPL_FAILCLOSE, REGEX_REPLACEALL_NO_G_FAILCLOSE, REGEX_SPLIT_LIMIT_FAILCLOSE, REGEX_SPLIT_ZEROWIDTH_FAILCLOSE, REGEX_TEST_G_FAILCLOSE, regexAstralFailMessage, regexCaptureMeta, regexIFoldFailMessage, regexLiteralReceiverIR, regexMethodRegexArgIdent, scanRegexAstral, suggestStdlibMethod, translateReplStringToPython, unmappedHostNamespaceMessage, unwrapTransparentReceiverIR, validateDecimalConstructionArg, validateDecimalDivModArgs, validateDecimalOperands, validateDecimalPowArgs, validateRegexNamedGroupsPortable, } from '@kernlang/core';
 // Slice 0.9 — the TypeScript-AST closure helpers + classifier live on the Node
 // subpath (the barrel is browser-safe). Python codegen is Node-side and parses
 // block-bodied arrows, so it injects `typescriptClosureClassifier`.
@@ -48,6 +48,7 @@ import { collectFreeIdentifierNames, lowerJsClosureBodyToPython, typescriptClosu
 import { buildPythonParamList } from './codegen-helpers.js';
 import { KERN_FMT_HELPER_PY, KERN_JS_ARRAY_FROM_HELPER_PY, KERN_JS_ARRAY_HELPERS_PY, KERN_JS_HELPER_PY, KERN_JS_MATH_HELPERS_PY, KERN_JS_NUMBER_HELPERS_PY, KERN_JS_OBJECT_HELPERS_PY, KERN_JSON_STRINGIFY_SHIM_PY, KERN_NULLISH_HELPER_PY, KERN_PAIR_HELPERS_PY, KERN_REGEX_MATCH_HELPER_PY, KERN_REGEX_MATCHALL_HELPER_PY, KERN_TMOD_HELPER_PY, KERN_TO_NUMBER_HELPER_PY, } from './core/expr/index.js';
 import { isSharedPortableArrayMethod, isSharedPortableArrayProperty, lowerPortableArrayMethodPy, lowerPortableArrayPropertyPy, sharedPortableMethodRequiresPureReceiver, } from './core/expr/list-ops.js';
+import { DOT_DICT_SHIM_PY } from './targets/python.js';
 import { mapTsTypeToPython } from './type-map.js';
 /** Parse options for Python codegen — always inject the TypeScript-backed
  *  closure classifier so block-bodied arrows parse (slice 0.9). */
@@ -58,6 +59,42 @@ const TS_PARSE_OPTS = { closureClassifier: typescriptClosureClassifier };
 function parseExpr(input) {
     return parseExpression(input, TS_PARSE_OPTS);
 }
+/** Property-specific fail-close for a non-length read/call on a nested record
+ *  array field — message LOCKSTEP with the TS twin (`nestedArrayMemberThrowTS`
+ *  in codegen-expression.ts): 'has no portable property "<name>"'. */
+const KERN_NESTED_NO_PROPERTY_HELPER_PY = `def _kern_nested_no_property(path, prop):
+    raise Exception('portable: nested array field "' + path + '" has no portable property "' + prop + '"')
+`;
+const KERN_NESTED_ARRAY_HELPER_PY = `def _kern_nested_array_value(record, field, index=None):
+    if not isinstance(record, dict) or field not in record:
+        raise Exception("portable: nested array receiver must be a record field")
+    value = record[field]
+    if not isinstance(value, list):
+        raise Exception("portable: nested record field must be an array")
+    if index is None:
+        return len(value)
+    if not isinstance(index, int) or isinstance(index, bool) or index < 0 or index >= len(value):
+        raise Exception("portable: nested array index must be an in-bounds non-negative safe integer")
+    out = value[index]
+    if not (out is None or isinstance(out, str) or isinstance(out, bool) or (isinstance(out, (int, float)) and not isinstance(out, bool) and out == out and out != float("inf") and out != float("-inf"))):
+        raise Exception("portable: nested array element must be a portable scalar")
+    return out
+`;
+const KERN_NESTED_ARRAY_REF_HELPER_PY = `def _kern_nested_array_ref(record, field):
+    if not isinstance(record, dict) or field not in record:
+        raise Exception("portable: nested array receiver must be a record field")
+    value = record[field]
+    if not isinstance(value, list):
+        raise Exception("portable: nested record field must be an array")
+    return value
+`;
+const KERN_NESTED_ARRAY_ITER_HELPER_PY = `def _kern_nested_array_iter(record, field):
+    value = _kern_nested_array_ref(record, field)
+    for out in value:
+        if not (out is None or isinstance(out, str) or isinstance(out, bool) or (isinstance(out, (int, float)) and not isinstance(out, bool) and out == out and out != float("inf") and out != float("-inf"))):
+            raise Exception("portable: nested array element must be a portable scalar")
+    return value
+`;
 const INDENT_STEP = '    ';
 function freshCtx(options) {
     return {
@@ -70,6 +107,12 @@ function freshCtx(options) {
         shadowedSymbols: new Set(),
         localScopes: [],
         regexScopes: [],
+        recordScopes: [],
+        recordArrayFieldScopes: [],
+        recordScalarArrayFieldScopes: [],
+        maybeRecordArrayFieldScopes: [],
+        arrayBindingScopes: [],
+        scalarArrayBindingScopes: [],
         renameStack: [],
         propagateStyle: options?.propagateStyle ?? 'value',
         usedPropagation: false,
@@ -169,6 +212,12 @@ export function emitNativeKernBodyPythonWithImports(handlerNode, options) {
         // no regex literal was assigned to it). Mirroring it here keeps regex
         // and local-binding scope stacks index-aligned.
         ctx.regexScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.recordScopes.push(new Map(outerBindings.map((n) => [n, false])));
+        ctx.recordArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.recordScalarArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.maybeRecordArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.arrayBindingScopes.push(new Map());
+        ctx.scalarArrayBindingScopes.push(new Map());
         ctx.renameStack.push(new Map());
     }
     try {
@@ -186,6 +235,12 @@ export function emitNativeKernBodyPythonWithImports(handlerNode, options) {
         if (outerBindings.length > 0) {
             ctx.localScopes.pop();
             ctx.regexScopes.pop();
+            ctx.recordScopes.pop();
+            ctx.recordArrayFieldScopes.pop();
+            ctx.recordScalarArrayFieldScopes.pop();
+            ctx.maybeRecordArrayFieldScopes.pop();
+            ctx.arrayBindingScopes.pop();
+            ctx.scalarArrayBindingScopes.pop();
             ctx.renameStack.pop();
         }
     }
@@ -259,10 +314,24 @@ function collectLoopAssignLastIndexes(children) {
         scan(children[i], i);
     return last;
 }
+function childrenCanFallThrough(children) {
+    for (const child of children) {
+        if (child.type === 'return' || child.type === 'throw' || child.type === 'break' || child.type === 'continue') {
+            return false;
+        }
+    }
+    return true;
+}
 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.recordScopes.push(new Map(initialBindings.map(([name]) => [name, false])));
+    ctx.recordArrayFieldScopes.push(new Map(initialBindings.map(([name]) => [name, null])));
+    ctx.recordScalarArrayFieldScopes.push(new Map(initialBindings.map(([name]) => [name, null])));
+    ctx.maybeRecordArrayFieldScopes.push(new Map(initialBindings.map(([name]) => [name, null])));
+    ctx.arrayBindingScopes.push(new Map());
+    ctx.scalarArrayBindingScopes.push(new Map());
     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
@@ -330,6 +399,9 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                 for (const line of emitFnPy(child, ctx, indent))
                     lines.push(line);
             }
+            else if (child.type === 'capability') {
+                throw new Error('capability nodes are not supported in emitted TypeScript/Python until an emitted capability ABI exists');
+            }
             else if (child.type === 'assign') {
                 // Same shadowing guard for a bare-identifier assignment target: after
                 // `assign target="e" …`, `e` is no longer the caught error.
@@ -391,11 +463,18 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                 // Wrap UNCONDITIONALLY (no "looks boolean" skip-analysis in v1).
                 ctx.helpers.add(KERN_JS_HELPER_PY);
                 lines.push(`${indent}if _kern_truthy(${emitPyExprCtx(condIR, ctx)}):`);
+                const branchBase = cloneBranchBindingScopes(ctx);
+                const branchOutcomes = [];
+                let remainingBranchReachable = !isStaticBooleanLiteral(condIR, true);
+                restoreBranchBindingScopes(ctx, branchBase);
                 const inner = emitChildrenPy(child.children ?? [], ctx, indent + INDENT_STEP);
                 if (inner.length === 0)
                     lines.push(`${indent}${INDENT_STEP}pass`);
                 for (const sl of inner)
                     lines.push(sl);
+                if (!isStaticBooleanLiteral(condIR, false) && childrenCanFallThrough(child.children ?? [])) {
+                    branchOutcomes.push(cloneBranchBindingScopes(ctx));
+                }
                 // Walk the `else` chain. Recognised shapes for `else`:
                 //   1. else > [if, else_inner]  → emit `elif`, recurse on else_inner
                 //   2. else > [if]              → terminal `elif` with no else
@@ -405,10 +484,12 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                 let elseCandidate = children[i + 1];
                 if (elseCandidate?.type === 'else')
                     i++;
+                let hasTerminalElse = false;
                 while (elseCandidate && elseCandidate.type === 'else') {
                     const ec = elseCandidate.children ?? [];
                     const isChainable = ec.length >= 1 && ec[0].type === 'if' && (ec.length === 1 || (ec.length === 2 && ec[1].type === 'else'));
                     if (isChainable) {
+                        restoreBranchBindingScopes(ctx, branchBase);
                         const ifNode = ec[0];
                         const nestedCondRaw = String(ifNode.props?.cond ?? '');
                         const nestedCondIR = parseExpr(nestedCondRaw);
@@ -423,18 +504,33 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                             lines.push(`${indent}${INDENT_STEP}pass`);
                         for (const sl of ifInner)
                             lines.push(sl);
+                        if (remainingBranchReachable &&
+                            !isStaticBooleanLiteral(nestedCondIR, false) &&
+                            childrenCanFallThrough(ifNode.children ?? [])) {
+                            branchOutcomes.push(cloneBranchBindingScopes(ctx));
+                        }
+                        if (isStaticBooleanLiteral(nestedCondIR, true))
+                            remainingBranchReachable = false;
                         elseCandidate = ec.length === 2 ? ec[1] : undefined;
                     }
                     else {
+                        restoreBranchBindingScopes(ctx, branchBase);
                         lines.push(`${indent}else:`);
                         const elseInner = emitChildrenPy(ec, ctx, indent + INDENT_STEP);
                         if (elseInner.length === 0)
                             lines.push(`${indent}${INDENT_STEP}pass`);
                         for (const el of elseInner)
                             lines.push(el);
+                        if (remainingBranchReachable && childrenCanFallThrough(ec))
+                            branchOutcomes.push(cloneBranchBindingScopes(ctx));
+                        hasTerminalElse = true;
+                        remainingBranchReachable = false;
                         break;
                     }
                 }
+                if (!hasTerminalElse && remainingBranchReachable)
+                    branchOutcomes.push(branchBase);
+                mergeBranchBindingSnapshots(ctx, branchBase, branchOutcomes);
             }
             else if (child.type === 'else') {
                 // Slice-2 review fix: orphan `else` is a structural error (matches TS side).
@@ -586,7 +682,8 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                     }
                     const k = String(pairKey);
                     const v = String(pairValue);
-                    const sourceExpr = emitPyExprCtx(listIR, ctx);
+                    assertNoKeyedNestedRecordReceiverPy(listIR, ctx);
+                    const sourceExpr = emitEachIterablePy(listIR, ctx);
                     ctx.helpers.add(KERN_PAIR_HELPERS_PY);
                     const iterableExpr = isAwait ? `_kern_async_pairs(${sourceExpr})` : `_kern_pairs(${sourceExpr})`;
                     lines.push(`${indent}${isAwait ? 'async ' : ''}for ${k}, ${v} in ${iterableExpr}:`);
@@ -616,7 +713,8 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                     if (entryKey && entryValue) {
                         throw new Error('body-statement `each` cannot combine `entryKey=` and `entryValue=`.');
                     }
-                    const sourceExpr = emitPyExprCtx(listIR, ctx);
+                    assertNoKeyedNestedRecordReceiverPy(listIR, ctx);
+                    const sourceExpr = emitEachIterablePy(listIR, ctx);
                     if (entryKey) {
                         const k = String(entryKey);
                         const iterableExpr = `${sourceExpr}.keys()`;
@@ -662,7 +760,7 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
                 // the IR-semantics differential audit (PR-3b).
                 const asName = String(child.props?.name ?? child.props?.as ?? 'item');
                 const idxName = child.props?.index !== undefined ? String(child.props.index) : null;
-                const iterableExpr = emitPyExprCtx(listIR, ctx);
+                const iterableExpr = emitEachIterablePy(listIR, ctx);
                 let primaryBindingPy;
                 let initialBindings;
                 if (idxName !== null) {
@@ -745,6 +843,12 @@ function emitChildrenPy(children, ctx, indent, initialBindings = [], isLoopBody
             ctx.loopLaterAssignFrames.pop();
         ctx.localScopes.pop();
         ctx.regexScopes.pop();
+        ctx.recordScopes.pop();
+        ctx.recordArrayFieldScopes.pop();
+        ctx.recordScalarArrayFieldScopes.pop();
+        ctx.maybeRecordArrayFieldScopes.pop();
+        ctx.arrayBindingScopes.pop();
+        ctx.scalarArrayBindingScopes.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
@@ -768,6 +872,17 @@ function resolveLocalRename(ctx, name) {
     }
     return name;
 }
+function emitScopedIdentPy(ctx, name) {
+    // Only custom nested-record rewrites need this helper; ordinary expression
+    // emission descends through the ident case, which already resolves block
+    // renames before applying symbol-map names.
+    const blockRename = resolveLocalRename(ctx, name);
+    if (blockRename !== name)
+        return blockRename;
+    if (ctx.shadowedSymbols.has(name))
+        return name;
+    return ctx.symbolMap[name] ?? name;
+}
 /** Returns the renamed name if `let name=` here would shadow a binding in
  * any OUTER scope; otherwise returns `name` unchanged. Used by `emitLetPy`
  * to give an inner-block shadow a unique Python name + record the rename
@@ -1067,6 +1182,8 @@ function emitLetPy(node, ctx) {
     }
     const valueIR = parseExpr(String(rawValue));
     setRegexBinding(ctx, userName, valueIR.kind === 'regexLit' ? valueIR : null);
+    setRecordBinding(ctx, userName, valueIR.kind === 'objectLit', recordArrayFieldsForValue(valueIR, ctx), recordScalarArrayFieldsForValue(valueIR, ctx));
+    bindArrayStatusFromLet(ctx, userName, valueIR);
     if (valueIR.kind === 'propagate' && valueIR.op === '?') {
         rejectPropagationInsideTry(ctx);
         const tmp = `__k_t${++ctx.gensymCounter}`;
@@ -1082,11 +1199,22 @@ function emitLetPy(node, ctx) {
             lines.push(letAssignTracePy(name));
         return lines;
     }
-    const lines = [`${name} = ${emitPyExprCtx(valueIR, ctx)}`];
+    const lines = [`${name} = ${emitLetInitializerPy(valueIR, ctx)}`];
     if (ctx.traceHooks?.letAssign)
         lines.push(letAssignTracePy(name));
     return lines;
 }
+/** RECORD-binding initializer wrap (nested-values slice-1): a `let` bound to a
+ *  DIRECT object literal becomes a `__DotDict` so certified field reads
+ *  (`r.a`, `r.length`) resolve on the Python leg. ONLY this position wraps —
+ *  inline/argument/return object literals keep base plain-dict emission. */
+function emitLetInitializerPy(valueIR, ctx) {
+    const rhs = emitPyExprCtx(valueIR, ctx);
+    if (valueIR.kind !== 'objectLit')
+        return rhs;
+    ctx.helpers.add(DOT_DICT_SHIM_PY);
+    return `__DotDict(${rhs})`;
+}
 function unwrapBodyExpr(value) {
     if (value === undefined || value === null)
         return undefined;
@@ -1371,6 +1499,7 @@ function emitAssignPy(node, ctx) {
         throw new Error('body-statement `assign target=` must be an identifier, member access, or index access.');
     }
     assertAssignableLocalTarget(targetIR, ctx);
+    applyArrayMutationAssignPy(targetIR, ctx);
     // Python lacks `++` / `--`; lower postfix mutation to the canonical compound
     // assignment (`X += 1` / `X -= 1`). The TS round-trip stays byte-equivalent
     // because TS emits `X++;` from the same IR — only the Python target diverges
@@ -1386,12 +1515,20 @@ function emitAssignPy(node, ctx) {
     // Emit FIRST (its `emitPyExprCtx` lowering fail-closes a regex method on a
     // bound regex ident) so the RHS is checked against the PRE-reassignment table
     // (`re = s.match(re)` must still see `re` as a regex). Mirrors the TS leg.
-    const stmt = `${emitPyExprCtx(targetIR, ctx)} ${rawOp} ${emitPyExprCtx(valueIR, ctx)}`;
+    // A plain-`=` ident reassignment to a DIRECT object literal takes the SAME
+    // __DotDict wrap as a record `let` initializer — `rebindRecordOnReassign`
+    // below re-marks the binding as a record, so the VALUE must be record-
+    // shaped too or later emitted field reads (attribute access) would hit a
+    // plain dict. Lockstep with `emitLetInitializerPy`.
+    const rhs = rawOp === '=' && targetIR.kind === 'ident' ? emitLetInitializerPy(valueIR, ctx) : emitPyExprCtx(valueIR, ctx);
+    const stmt = `${emitPyExprCtx(targetIR, ctx)} ${rawOp} ${rhs}`;
     // Reassign-invalidation (Slice-3c): keep the regex-binding table honest. A
     // plain `=` to a direct regex literal stays a regex binding (still
     // fail-closed); any compound op (`+=`, …) or non-regex RHS UNMARKS it.
     if (targetIR.kind === 'ident') {
         rebindRegexOnReassign(ctx, targetIR.name, rawOp === '=' ? valueIR : { kind: 'undefLit' });
+        rebindRecordOnReassign(ctx, targetIR.name, rawOp === '=' ? valueIR : { kind: 'undefLit' });
+        rebindArrayOnReassign(ctx, targetIR.name, rawOp === '=' ? valueIR : { kind: 'undefLit' });
     }
     // Differential-harness opt-in (see BodyEmitOptions.traceHooks.letAssign): the
     // `assign` contract observes a reassignment via the same `{op:"assign"}` event
@@ -1411,6 +1548,8 @@ function declareLocalBinding(ctx, name, kind) {
     }
     scope.set(name, kind);
     setRegexBinding(ctx, name, null);
+    setRecordBinding(ctx, name, false);
+    setArrayBindingStatus(ctx, name, null);
 }
 function setRegexBinding(ctx, name, regex) {
     ctx.regexScopes.at(-1)?.set(name, regex);
@@ -1439,6 +1578,360 @@ function rebindRegexOnReassign(ctx, name, valueIR) {
         }
     }
 }
+/** Record whether `name` is bound to a DIRECT record literal in the current scope. */
+function setRecordBinding(ctx, name, isRecord, arrayFields = null, scalarArrayFields = null) {
+    ctx.recordScopes.at(-1)?.set(name, isRecord);
+    ctx.recordArrayFieldScopes.at(-1)?.set(name, isRecord ? arrayFields : null);
+    ctx.recordScalarArrayFieldScopes.at(-1)?.set(name, isRecord ? scalarArrayFields : null);
+    ctx.maybeRecordArrayFieldScopes.at(-1)?.set(name, isRecord ? arrayFields : null);
+}
+function recordArrayFieldsForValue(valueIR, ctx) {
+    if (valueIR.kind !== 'objectLit')
+        return null;
+    const fields = new Set();
+    for (const entry of valueIR.entries) {
+        if ('kind' in entry)
+            continue;
+        if (entry.value.kind === 'arrayLit') {
+            assertPortableArrayLiteralElementsPy(entry.value);
+            fields.add(entry.key);
+        }
+        else if (entry.value.kind === 'ident') {
+            const status = lookupArrayBindingStatus(ctx, entry.value.name);
+            if (status === 'fresh' || status === 'fresh-push' || status === 'captured')
+                fields.add(entry.key);
+        }
+    }
+    return fields;
+}
+function recordScalarArrayFieldsForValue(valueIR, ctx) {
+    if (valueIR.kind !== 'objectLit')
+        return null;
+    const fields = new Set();
+    for (const entry of valueIR.entries) {
+        if ('kind' in entry)
+            continue;
+        if (entry.value.kind === 'arrayLit' && arrayLiteralHasOnlyScalarElements(entry.value))
+            fields.add(entry.key);
+        else if (entry.value.kind === 'ident') {
+            const status = lookupArrayBindingStatus(ctx, entry.value.name);
+            if ((status === 'fresh' || status === 'fresh-push' || status === 'captured') &&
+                lookupScalarArrayBinding(ctx, entry.value.name)) {
+                fields.add(entry.key);
+            }
+        }
+    }
+    return fields;
+}
+function assertPortableArrayLiteralElementsPy(valueIR) {
+    for (const item of valueIR.items) {
+        if (item.kind === 'arrayLit') {
+            assertPortableArrayLiteralElementsPy(item);
+            continue;
+        }
+        if (item.kind === 'strLit' || item.kind === 'boolLit' || item.kind === 'nullLit')
+            continue;
+        if (item.kind === 'numLit' && item.bigint !== true && Number.isFinite(item.value)) {
+            if (isIntegerValuedFloatLiteralPy(item))
+                throw new Error('portable: float literal has an integer value (float/int divergence)');
+            continue;
+        }
+        throw new Error('portable-array: array literal fields must contain only portable scalar or array elements');
+    }
+}
+function arrayLiteralHasOnlyScalarElements(valueIR) {
+    return valueIR.items.every((item) => (item.kind === 'numLit' &&
+        item.bigint !== true &&
+        Number.isFinite(item.value) &&
+        !isIntegerValuedFloatLiteralPy(item)) ||
+        item.kind === 'strLit' ||
+        item.kind === 'boolLit' ||
+        item.kind === 'nullLit');
+}
+function setArrayBindingStatus(ctx, name, status) {
+    const scope = ctx.arrayBindingScopes.at(-1);
+    if (!scope)
+        return;
+    if (status === null)
+        scope.delete(name);
+    else
+        scope.set(name, status);
+}
+function setScalarArrayBinding(ctx, name, scalar) {
+    const scope = ctx.scalarArrayBindingScopes.at(-1);
+    if (!scope)
+        return;
+    if (scalar)
+        scope.set(name, true);
+    else
+        scope.delete(name);
+}
+function lookupArrayBindingStatus(ctx, name) {
+    for (let i = ctx.localScopes.length - 1; i >= 0; i--) {
+        if (!ctx.localScopes[i].has(name))
+            continue;
+        return ctx.arrayBindingScopes[i]?.get(name) ?? null;
+    }
+    return null;
+}
+function lookupScalarArrayBinding(ctx, name) {
+    for (let i = ctx.localScopes.length - 1; i >= 0; i--) {
+        if (!ctx.localScopes[i].has(name))
+            continue;
+        return ctx.scalarArrayBindingScopes[i]?.get(name) === true;
+    }
+    return false;
+}
+function setDeclaringArrayBindingStatus(ctx, name, status) {
+    for (let i = ctx.localScopes.length - 1; i >= 0; i--) {
+        if (!ctx.localScopes[i].has(name))
+            continue;
+        const scope = ctx.arrayBindingScopes[i];
+        if (status === null)
+            scope?.delete(name);
+        else
+            scope?.set(name, status);
+        return;
+    }
+}
+function setDeclaringScalarArrayBinding(ctx, name, scalar) {
+    for (let i = ctx.localScopes.length - 1; i >= 0; i--) {
+        if (!ctx.localScopes[i].has(name))
+            continue;
+        const scope = ctx.scalarArrayBindingScopes[i];
+        if (scalar)
+            scope?.set(name, true);
+        else
+            scope?.delete(name);
+        return;
+    }
+}
+function assertFreshArrayCaptureNotInRepeatableLoopPy(ctx, name) {
+    const loopScopeIndex = ctx.loopScopeIndexes.at(-1);
+    if (loopScopeIndex === undefined)
+        return;
+    const scopeIndex = findBindingScopeIndex(ctx, name);
+    if (scopeIndex !== null && scopeIndex < loopScopeIndex) {
+        throw new Error(`fresh array binding "${name}" cannot be captured inside a repeatable loop body`);
+    }
+}
+function isStaticBooleanLiteral(node, value) {
+    return node.kind === 'boolLit' && node.value === value;
+}
+function cloneFieldScopes(scopes) {
+    return scopes.map((scope) => new Map([...scope.entries()].map(([name, fields]) => [name, fields === null ? null : new Set(fields)])));
+}
+function cloneBranchBindingScopes(ctx) {
+    return {
+        array: ctx.arrayBindingScopes.map((scope) => new Map(scope)),
+        scalarArray: ctx.scalarArrayBindingScopes.map((scope) => new Map(scope)),
+        record: ctx.recordScopes.map((scope) => new Map(scope)),
+        recordArrayField: cloneFieldScopes(ctx.recordArrayFieldScopes),
+        recordScalarArrayField: cloneFieldScopes(ctx.recordScalarArrayFieldScopes),
+        maybeRecordArrayField: cloneFieldScopes(ctx.maybeRecordArrayFieldScopes),
+    };
+}
+function restoreBranchBindingScopes(ctx, snapshot) {
+    ctx.arrayBindingScopes = snapshot.array.map((scope) => new Map(scope));
+    ctx.scalarArrayBindingScopes = snapshot.scalarArray.map((scope) => new Map(scope));
+    ctx.recordScopes = snapshot.record.map((scope) => new Map(scope));
+    ctx.recordArrayFieldScopes = cloneFieldScopes(snapshot.recordArrayField);
+    ctx.recordScalarArrayFieldScopes = cloneFieldScopes(snapshot.recordScalarArrayField);
+    ctx.maybeRecordArrayFieldScopes = cloneFieldScopes(snapshot.maybeRecordArrayField);
+}
+function strongestArrayBindingStatus(statuses) {
+    if (statuses.includes('captured'))
+        return 'captured';
+    if (statuses.includes('stale'))
+        return 'stale';
+    if (statuses.includes('fresh'))
+        return 'fresh';
+    if (statuses.includes('fresh-push'))
+        return 'fresh-push';
+    return null;
+}
+function mergeArrayScopes(base, outcomes) {
+    const merged = base.map((scope) => new Map(scope));
+    for (let scopeIndex = 0; scopeIndex < merged.length; scopeIndex++) {
+        const names = new Set(merged[scopeIndex].keys());
+        for (const outcome of outcomes)
+            for (const name of outcome[scopeIndex]?.keys() ?? [])
+                names.add(name);
+        for (const name of names) {
+            const status = strongestArrayBindingStatus(outcomes.map((outcome) => outcome[scopeIndex]?.get(name) ?? null));
+            if (status === null)
+                merged[scopeIndex].delete(name);
+            else
+                merged[scopeIndex].set(name, status);
+        }
+    }
+    return merged;
+}
+function mergeScalarArrayScopes(base, outcomes) {
+    const merged = base.map((scope) => new Map(scope));
+    for (let scopeIndex = 0; scopeIndex < merged.length; scopeIndex++) {
+        const names = new Set(merged[scopeIndex].keys());
+        for (const outcome of outcomes)
+            for (const name of outcome[scopeIndex]?.keys() ?? [])
+                names.add(name);
+        for (const name of names) {
+            const scalar = outcomes.length > 0 && outcomes.every((outcome) => outcome[scopeIndex]?.get(name) === true);
+            if (scalar)
+                merged[scopeIndex].set(name, true);
+            else
+                merged[scopeIndex].delete(name);
+        }
+    }
+    return merged;
+}
+function mergeRecordScopes(base, outcomes) {
+    const merged = base.map((scope) => new Map(scope));
+    for (let scopeIndex = 0; scopeIndex < merged.length; scopeIndex++) {
+        const names = new Set(merged[scopeIndex].keys());
+        for (const outcome of outcomes)
+            for (const name of outcome[scopeIndex]?.keys() ?? [])
+                names.add(name);
+        for (const name of names) {
+            merged[scopeIndex].set(name, outcomes.length > 0 && outcomes.every((outcome) => outcome[scopeIndex]?.get(name) === true));
+        }
+    }
+    return merged;
+}
+function mergeFieldScopes(base, outcomes, mode) {
+    const merged = base.map((scope) => new Map(scope));
+    for (let scopeIndex = 0; scopeIndex < merged.length; scopeIndex++) {
+        const names = new Set(merged[scopeIndex].keys());
+        for (const outcome of outcomes)
+            for (const name of outcome[scopeIndex]?.keys() ?? [])
+                names.add(name);
+        for (const name of names) {
+            const outcomeFields = outcomes.map((outcome) => outcome[scopeIndex]?.get(name) ?? null);
+            const fields = new Set();
+            if (mode === 'union') {
+                for (const set of outcomeFields)
+                    if (set)
+                        for (const field of set)
+                            fields.add(field);
+            }
+            else if (outcomeFields.length > 0 && outcomeFields.every((set) => set !== null)) {
+                for (const field of outcomeFields[0] ?? []) {
+                    if (outcomeFields.every((set) => set?.has(field) === true))
+                        fields.add(field);
+                }
+            }
+            merged[scopeIndex].set(name, fields.size > 0 ? fields : null);
+        }
+    }
+    return merged;
+}
+function mergeBranchBindingSnapshots(ctx, base, outcomes) {
+    ctx.arrayBindingScopes = mergeArrayScopes(base.array, outcomes.map((outcome) => outcome.array));
+    ctx.scalarArrayBindingScopes = mergeScalarArrayScopes(base.scalarArray, outcomes.map((outcome) => outcome.scalarArray));
+    ctx.recordScopes = mergeRecordScopes(base.record, outcomes.map((outcome) => outcome.record));
+    ctx.recordArrayFieldScopes = mergeFieldScopes(base.recordArrayField, outcomes.map((outcome) => outcome.recordArrayField), 'intersection');
+    ctx.recordScalarArrayFieldScopes = mergeFieldScopes(base.recordScalarArrayField, outcomes.map((outcome) => outcome.recordScalarArrayField), 'intersection');
+    ctx.maybeRecordArrayFieldScopes = mergeFieldScopes(base.maybeRecordArrayField, outcomes.map((outcome) => outcome.maybeRecordArrayField), 'union');
+}
+function lookupRecordBinding(ctx, name) {
+    for (let i = ctx.recordScopes.length - 1; i >= 0; i--) {
+        const scope = ctx.recordScopes[i];
+        if (scope.has(name))
+            return scope.get(name) === true;
+    }
+    return false;
+}
+function lookupRecordArrayField(ctx, name, field) {
+    for (let i = ctx.recordArrayFieldScopes.length - 1; i >= 0; i--) {
+        const scope = ctx.recordArrayFieldScopes[i];
+        if (!scope.has(name))
+            continue;
+        return scope.get(name)?.has(field) === true;
+    }
+    return false;
+}
+function lookupRecordScalarArrayField(ctx, name, field) {
+    for (let i = ctx.recordScalarArrayFieldScopes.length - 1; i >= 0; i--) {
+        const scope = ctx.recordScalarArrayFieldScopes[i];
+        if (!scope.has(name))
+            continue;
+        return scope.get(name)?.has(field) === true;
+    }
+    return false;
+}
+function lookupMaybeRecordArrayField(ctx, name, field) {
+    for (let i = ctx.maybeRecordArrayFieldScopes.length - 1; i >= 0; i--) {
+        const scope = ctx.maybeRecordArrayFieldScopes[i];
+        if (!scope.has(name))
+            continue;
+        return scope.get(name)?.has(field) === true;
+    }
+    return false;
+}
+function bindArrayStatusFromLet(ctx, name, valueIR) {
+    if (valueIR.kind === 'arrayLit') {
+        setArrayBindingStatus(ctx, name, valueIR.items.length === 0 ? 'fresh-push' : 'fresh');
+        setScalarArrayBinding(ctx, name, arrayLiteralHasOnlyScalarElements(valueIR));
+        return;
+    }
+    if (valueIR.kind === 'ident') {
+        const sourceStatus = lookupArrayBindingStatus(ctx, valueIR.name);
+        const sourceScalar = lookupScalarArrayBinding(ctx, valueIR.name);
+        if (sourceStatus === 'fresh' || sourceStatus === 'fresh-push') {
+            setDeclaringArrayBindingStatus(ctx, valueIR.name, 'stale');
+            setDeclaringScalarArrayBinding(ctx, valueIR.name, false);
+            setArrayBindingStatus(ctx, name, 'stale');
+            setScalarArrayBinding(ctx, name, false);
+            return;
+        }
+        if (sourceStatus === 'captured') {
+            setArrayBindingStatus(ctx, name, 'captured');
+            setScalarArrayBinding(ctx, name, sourceScalar);
+            return;
+        }
+        if (sourceStatus === 'stale') {
+            setArrayBindingStatus(ctx, name, 'stale');
+            setScalarArrayBinding(ctx, name, false);
+            return;
+        }
+    }
+    if (valueIR.kind === 'member' &&
+        valueIR.object.kind === 'ident' &&
+        lookupRecordArrayField(ctx, valueIR.object.name, valueIR.property)) {
+        setArrayBindingStatus(ctx, name, 'captured');
+        setScalarArrayBinding(ctx, name, lookupRecordScalarArrayField(ctx, valueIR.object.name, valueIR.property));
+        return;
+    }
+    setArrayBindingStatus(ctx, name, null);
+    setScalarArrayBinding(ctx, name, false);
+}
+function rebindArrayOnReassign(ctx, name, valueIR) {
+    if (valueIR.kind === 'arrayLit') {
+        setDeclaringArrayBindingStatus(ctx, name, 'stale');
+        setDeclaringScalarArrayBinding(ctx, name, false);
+    }
+    else {
+        setDeclaringArrayBindingStatus(ctx, name, null);
+        setDeclaringScalarArrayBinding(ctx, name, false);
+    }
+}
+/** Reassign-invalidation for the record table — mirrors `rebindRegexOnReassign`
+ *  (and the TS emitter's `rebindRecordOnReassign`): owning-scope update, no
+ *  stale record classification after `assign target=r value=<non-record>`. */
+function rebindRecordOnReassign(ctx, name, valueIR) {
+    const next = valueIR.kind === 'objectLit';
+    const arrayFields = recordArrayFieldsForValue(valueIR, ctx);
+    const scalarArrayFields = recordScalarArrayFieldsForValue(valueIR, ctx);
+    for (let i = ctx.recordScopes.length - 1; i >= 0; i--) {
+        const scope = ctx.recordScopes[i];
+        if (scope.has(name)) {
+            scope.set(name, next);
+            ctx.recordArrayFieldScopes[i]?.set(name, next ? arrayFields : null);
+            ctx.recordScalarArrayFieldScopes[i]?.set(name, next ? scalarArrayFields : null);
+            ctx.maybeRecordArrayFieldScopes[i]?.set(name, next ? arrayFields : null);
+            return;
+        }
+    }
+}
 function assertAssignableLocalTarget(target, ctx) {
     if (target.kind !== 'ident')
         return;
@@ -1777,7 +2270,7 @@ function emitDoPy(node, ctx) {
         ctx.usedPropagation = true;
         return [`${tmp} = ${inner}`, `if ${tmp}.kind == 'err':`, errPropagationLine(tmp, ctx)];
     }
-    return [`${emitPyExprCtx(valueIR, ctx)}`];
+    return [`${emitPyExprCtx(valueIR, ctx, { preserveFreshPush: true })}`];
 }
 /** ValueIR `kind`s that lower to Python literals/values and would trigger
  *  `TypeError: exceptions must derive from BaseException` if `raise`d
@@ -1822,12 +2315,213 @@ export function emitPyExpressionWithImports(node, options) {
     if (outerBindings.length > 0) {
         ctx.localScopes.push(new Map(outerBindings.map((n) => [n, 'const'])));
         ctx.regexScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.recordScopes.push(new Map(outerBindings.map((n) => [n, false])));
+        ctx.recordArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.recordScalarArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.maybeRecordArrayFieldScopes.push(new Map(outerBindings.map((n) => [n, null])));
+        ctx.arrayBindingScopes.push(new Map());
+        ctx.scalarArrayBindingScopes.push(new Map());
         ctx.renameStack.push(new Map());
     }
     const code = emitPyExprCtx(node, ctx);
     return { code, imports: ctx.imports, helpers: ctx.helpers };
 }
-function emitPyExprCtx(node, ctx) {
+const MUTATING_ARRAY_METHODS = new Set([
+    'copyWithin',
+    'fill',
+    'pop',
+    'push',
+    'reverse',
+    'shift',
+    'sort',
+    'splice',
+    'unshift',
+]);
+function captureFreshArrayRecordSourcesPy(node, ctx) {
+    const freshSources = new Set();
+    for (const entry of node.entries) {
+        if ('kind' in entry)
+            continue;
+        if (entry.value.kind === 'member' &&
+            entry.value.object.kind === 'ident' &&
+            lookupMaybeRecordArrayField(ctx, entry.value.object.name, entry.value.property)) {
+            throw new Error(`record field "${entry.value.object.name}.${entry.value.property}" cannot be captured by another record field`);
+        }
+        if (entry.value.kind !== 'ident')
+            continue;
+        const status = lookupArrayBindingStatus(ctx, entry.value.name);
+        if (status === 'fresh' || status === 'fresh-push') {
+            if (freshSources.has(entry.value.name)) {
+                throw new Error(`fresh array binding "${entry.value.name}" can be captured only once`);
+            }
+            assertFreshArrayCaptureNotInRepeatableLoopPy(ctx, entry.value.name);
+            freshSources.add(entry.value.name);
+        }
+        else if (status === 'captured') {
+            throw new Error(`fresh array binding "${entry.value.name}" was already captured by a record field`);
+        }
+        else if (status === 'stale') {
+            throw new Error(`stale array binding "${entry.value.name}" cannot be captured by a record field`);
+        }
+    }
+    for (const name of freshSources)
+        setDeclaringArrayBindingStatus(ctx, name, 'captured');
+}
+function rootIdentName(node) {
+    if (node.kind === 'ident')
+        return node.name;
+    if (node.kind === 'member' || node.kind === 'index')
+        return rootIdentName(node.object);
+    return null;
+}
+function recordArrayFieldMutationTarget(node, ctx) {
+    if (node.kind === 'member' &&
+        node.object.kind === 'ident' &&
+        lookupMaybeRecordArrayField(ctx, node.object.name, node.property)) {
+        return { recordName: node.object.name, fieldName: node.property };
+    }
+    if (node.kind === 'member' || node.kind === 'index')
+        return recordArrayFieldMutationTarget(node.object, ctx);
+    return null;
+}
+function isIntegerValuedFloatLiteralPy(node) {
+    return (node.raw.includes('.') || /[eE]/.test(node.raw)) && Number.isInteger(node.value);
+}
+function isFreshnessPreservingPushElementPy(node) {
+    if (node.kind === 'strLit' || node.kind === 'boolLit' || node.kind === 'nullLit')
+        return true;
+    if (node.kind !== 'numLit')
+        return false;
+    if (node.bigint || !Number.isFinite(node.value))
+        return false;
+    if (isIntegerValuedFloatLiteralPy(node))
+        throw new Error('portable: float literal has an integer value (float/int divergence)');
+    return true;
+}
+function pushMutationTargetPy(node) {
+    if (node.kind !== 'call' || node.optional || node.args.length !== 1)
+        return null;
+    const callee = node.callee;
+    if (callee.kind !== 'member' || callee.optional || callee.property !== 'push')
+        return null;
+    return { target: callee.object, element: node.args[0] };
+}
+function applyArrayMutationTargetPy(target, ctx, preserveFreshPush = false) {
+    const recordField = recordArrayFieldMutationTarget(target, ctx);
+    if (recordField !== null) {
+        throw new Error(`record array field "${recordField.recordName}.${recordField.fieldName}" cannot be mutated after capture`);
+    }
+    const targetName = rootIdentName(target);
+    if (targetName === null)
+        return;
+    const status = lookupArrayBindingStatus(ctx, targetName);
+    if (status === 'captured') {
+        throw new Error(`fresh array binding "${targetName}" was already captured by a record field`);
+    }
+    if (status === 'fresh-push' && preserveFreshPush)
+        return;
+    if (status === 'fresh' || status === 'fresh-push')
+        setDeclaringArrayBindingStatus(ctx, targetName, 'stale');
+}
+function applyArrayMutationDoPy(node, ctx, preserveFreshPush = false) {
+    const pushTarget = pushMutationTargetPy(node);
+    if (pushTarget !== null) {
+        const keepFresh = preserveFreshPush && isFreshnessPreservingPushElementPy(pushTarget.element);
+        applyArrayMutationTargetPy(pushTarget.target, ctx, keepFresh);
+        return;
+    }
+    if (node.kind !== 'call')
+        return;
+    const callee = node.callee;
+    if (callee.kind === 'member' && MUTATING_ARRAY_METHODS.has(callee.property))
+        applyArrayMutationTargetPy(callee.object, ctx);
+}
+function applyArrayMutationAssignPy(target, ctx) {
+    if (target.kind === 'ident') {
+        const status = lookupArrayBindingStatus(ctx, target.name);
+        if (status === 'captured') {
+            throw new Error(`fresh array binding "${target.name}" was already captured by a record field`);
+        }
+        if (status === 'fresh' || status === 'fresh-push' || status === 'stale') {
+            throw new Error(`array binding "${target.name}" cannot be reassigned by portable assign`);
+        }
+        return;
+    }
+    applyArrayMutationTargetPy(target, ctx);
+}
+function forEachValueIRChildPy(node, visit) {
+    if (node.kind === 'member')
+        visit(node.object);
+    else if (node.kind === 'index') {
+        visit(node.object);
+        visit(node.index);
+    }
+    else if (node.kind === 'call') {
+        visit(node.callee);
+        for (const arg of node.args)
+            visit(arg);
+    }
+    else if (node.kind === 'binary') {
+        visit(node.left);
+        visit(node.right);
+    }
+    else if (node.kind === 'unary' ||
+        node.kind === 'spread' ||
+        node.kind === 'await' ||
+        node.kind === 'new' ||
+        node.kind === 'propagate') {
+        visit(node.argument);
+    }
+    else if (node.kind === 'typeAssert' || node.kind === 'nonNull')
+        visit(node.expression);
+    else if (node.kind === 'conditional') {
+        visit(node.test);
+        visit(node.consequent);
+        visit(node.alternate);
+    }
+    else if (node.kind === 'tmplLit')
+        for (const expr of node.expressions)
+            visit(expr);
+    else if (node.kind === 'objectLit') {
+        for (const entry of node.entries) {
+            if ('kind' in entry && entry.kind === 'spread')
+                visit(entry.argument);
+            else
+                visit(entry.value);
+        }
+    }
+    else if (node.kind === 'arrayLit')
+        for (const item of node.items)
+            visit(item);
+    else if (node.kind === 'lambda' && node.body)
+        visit(node.body);
+}
+function applyArrayMutationsInExpressionPy(node, ctx, preserveFreshPush = false) {
+    applyArrayMutationDoPy(node, ctx, preserveFreshPush);
+    // Only a direct `do xs.push(<scalar>)` statement certifies the push-built freshness chain.
+    // Nested pushes inside a larger expression are still mutation expressions and must stale.
+    forEachValueIRChildPy(node, (child) => applyArrayMutationsInExpressionPy(child, ctx));
+}
+function assertRecordArrayFieldReadsProvenPy(node, ctx) {
+    if (node.kind === 'member' &&
+        node.object.kind === 'ident' &&
+        lookupMaybeRecordArrayField(ctx, node.object.name, node.property) &&
+        (node.optional || isParenthesized(node.object))) {
+        throw new Error(`record array field "${node.object.name}.${node.property}" must use a bare non-optional receiver`);
+    }
+    if (node.kind === 'member' &&
+        node.object.kind === 'ident' &&
+        lookupMaybeRecordArrayField(ctx, node.object.name, node.property) &&
+        !lookupRecordArrayField(ctx, node.object.name, node.property)) {
+        throw new Error(`record array field "${node.object.name}.${node.property}" is not proven on every branch`);
+    }
+    forEachValueIRChildPy(node, (child) => assertRecordArrayFieldReadsProvenPy(child, ctx));
+}
+function emitPyExprCtx(node, ctx, options = {}) {
+    applyArrayMutationsInExpressionPy(node, ctx, options.preserveFreshPush === true);
+    assertRecordArrayFieldReadsProvenPy(node, ctx);
+    if (node.kind === 'objectLit')
+        captureFreshArrayRecordSourcesPy(node, ctx);
     switch (node.kind) {
         case 'numLit':
             return node.raw;
@@ -2255,7 +2949,10 @@ function emitPyExprCtx(node, ctx) {
         }
         case 'objectLit': {
             // Slice 2d — Python dict literal. Keys are ALWAYS double-quoted (no
-            // shorthand-key syntax in Python).
+            // shorthand-key syntax in Python). Emits the BASE plain-dict form —
+            // record-binding `let` initializers (the ONLY position where field
+            // reads are certified) wrap in __DotDict at the let site, so every
+            // other object-literal position keeps its pre-slice bytes.
             const entries = node.entries.map((e) => {
                 if ('kind' in e && e.kind === 'spread') {
                     return `**${emitPyExprCtx(e.argument, ctx)}`;
@@ -2777,9 +3474,118 @@ function lowerOptionalLink(inner, objectNode, ctx) {
     const presence = optionalPresenceTest(`${tmp} := ${inner.expr}`, ctx);
     return { guard: presence, branchRef: tmp };
 }
+/** Nested-record-field receiver, LOCKSTEP with the TS twin
+ *  (`nestedRecordFieldReceiver` in codegen-expression.ts): fires ONLY when the
+ *  binding table proves the SOURCE-named ident is a record literal; any other
+ *  two-level chain (`this.data.filter(...)`, object params, unproven idents,
+ *  parenthesized receivers) keeps its base lowering. INVARIANT: the lookup is
+ *  by SOURCE name, but the EMITTED name goes through `ctx.symbolMap` — Python's
+ *  flat function scope renames shadowed bindings, while the TS leg never
+ *  renames (real block scoping), which is why the TS twin has no remap. */
+function provenRecordFieldReceiverPy(node, ctx) {
+    if (node.kind !== 'member' || node.optional)
+        return null;
+    if (node.object.kind !== 'ident')
+        return null;
+    if (!lookupRecordBinding(ctx, node.object.name))
+        return null;
+    if (isParenthesized(node.object))
+        return null;
+    return { record: emitScopedIdentPy(ctx, node.object.name), field: node.property };
+}
+function nestedRecordFieldReceiverPy(node, ctx) {
+    if (node.kind !== 'member' || node.object.kind !== 'ident')
+        return null;
+    const proven = provenRecordFieldReceiverPy(node, ctx);
+    if (proven === null)
+        return null;
+    if (!lookupRecordArrayField(ctx, node.object.name, node.property))
+        return null;
+    return proven;
+}
+function nestedRecordFieldNonArrayReceiverPy(node, ctx) {
+    if (node.kind !== 'member' || node.object.kind !== 'ident')
+        return null;
+    const proven = provenRecordFieldReceiverPy(node, ctx);
+    if (proven === null)
+        return null;
+    if (lookupRecordArrayField(ctx, node.object.name, node.property))
+        return null;
+    return proven;
+}
+function emitEachIterablePy(node, ctx) {
+    if (node.kind === 'member' && node.object.kind === 'ident') {
+        if (!lookupRecordBinding(ctx, node.object.name))
+            return emitPyExprCtx(node, ctx);
+        if (node.optional || isParenthesized(node.object)) {
+            throw new Error(`each nested record-array receiver "${node.object.name}.${node.property}" is not proven`);
+        }
+        if (lookupMaybeRecordArrayField(ctx, node.object.name, node.property) &&
+            !lookupRecordArrayField(ctx, node.object.name, node.property)) {
+            throw new Error(`record array field "${node.object.name}.${node.property}" is not proven on every branch`);
+        }
+        if (lookupRecordArrayField(ctx, node.object.name, node.property) &&
+            !lookupRecordScalarArrayField(ctx, node.object.name, node.property)) {
+            throw new Error(`record array field "${node.object.name}.${node.property}" elements are not proven portable scalars`);
+        }
+        ctx.helpers.add(KERN_NESTED_ARRAY_REF_HELPER_PY);
+        ctx.helpers.add(KERN_NESTED_ARRAY_ITER_HELPER_PY);
+        const record = emitScopedIdentPy(ctx, node.object.name);
+        return `_kern_nested_array_iter(${record}, ${JSON.stringify(node.property)})`;
+    }
+    return emitPyExprCtx(node, ctx);
+}
+function assertNoKeyedNestedRecordReceiverPy(node, ctx) {
+    if (node.kind !== 'member' || node.object.kind !== 'ident')
+        return;
+    if (!lookupRecordBinding(ctx, node.object.name))
+        return;
+    if (node.optional || isParenthesized(node.object))
+        return;
+    throw new Error(`keyed iteration over nested record field "${node.object.name}.${node.property}" is outside the portable domain`);
+}
 function lowerChain(node, ctx) {
     if (node.kind === 'member') {
         const obj = node.object;
+        const directArrayField = nestedRecordFieldReceiverPy(node, ctx);
+        if (directArrayField !== null) {
+            ctx.helpers.add(KERN_NESTED_ARRAY_REF_HELPER_PY);
+            return {
+                guard: null,
+                expr: `_kern_nested_array_ref(${directArrayField.record}, ${JSON.stringify(directArrayField.field)})`,
+            };
+        }
+        const nested = nestedRecordFieldReceiverPy(obj, ctx);
+        if (nested !== null) {
+            if (node.optional)
+                throw new Error('portable: optional nested member access is outside the portable domain');
+            if (node.property !== 'length') {
+                ctx.helpers.add(KERN_NESTED_NO_PROPERTY_HELPER_PY);
+                return {
+                    guard: null,
+                    expr: `_kern_nested_no_property(${JSON.stringify(`${nested.record}.${nested.field}`)}, ${JSON.stringify(node.property)})`,
+                };
+            }
+            ctx.helpers.add(KERN_NESTED_ARRAY_HELPER_PY);
+            return { guard: null, expr: `_kern_nested_array_value(${nested.record}, ${JSON.stringify(nested.field)})` };
+        }
+        const nonArrayNested = nestedRecordFieldNonArrayReceiverPy(obj, ctx);
+        if (nonArrayNested !== null) {
+            if (node.optional)
+                throw new Error('portable: optional nested member access is outside the portable domain');
+            if (node.property !== 'length') {
+                ctx.helpers.add(KERN_NESTED_NO_PROPERTY_HELPER_PY);
+                return {
+                    guard: null,
+                    expr: `_kern_nested_no_property(${JSON.stringify(`${nonArrayNested.record}.${nonArrayNested.field}`)}, ${JSON.stringify(node.property)})`,
+                };
+            }
+            ctx.helpers.add(KERN_NESTED_ARRAY_HELPER_PY);
+            return {
+                guard: null,
+                expr: `_kern_nested_array_value(${nonArrayNested.record}, ${JSON.stringify(nonArrayNested.field)})`,
+            };
+        }
         // Error-substrate Slice 1 — a `<caughtBinding>.message` read lowers to
         // `str(<caughtBinding>)`. Python exceptions have NO `.message` attribute
         // (a bare `e.message` raises AttributeError), but `str(Exception("x"))`
@@ -2829,6 +3635,11 @@ function lowerChain(node, ctx) {
         const inner = obj.kind === 'member' || obj.kind === 'call' || obj.kind === 'index'
             ? lowerChain(obj, ctx)
             : { guard: null, expr: wrapCompoundRootExpr(obj, emitPyExprCtx(obj, ctx)) };
+        // Nested-values slice-1 — a PROVEN record binding's single-level member
+        // read must stay an ATTRIBUTE read even for shared array property names
+        // (`r.length` is the scalar FIELD "length" on a __DotDict, never len(r));
+        // every other receiver keeps the base shared list-ops lowering below.
+        const recordReceiver = obj.kind === 'ident' && lookupRecordBinding(ctx, obj.name);
         // 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
@@ -2846,18 +3657,52 @@ function lowerChain(node, ctx) {
             // receiver is not itself an optional chain ⇒ `inner.guard === null`); a
             // non-pure receiver UNDER an existing optional chain still throws below.
             const opt = lowerOptionalLink(inner, node.object, ctx);
-            const linkExpr = isSharedPortableArrayProperty(node.property)
+            const linkExpr = !recordReceiver && isSharedPortableArrayProperty(node.property)
                 ? (lowerPortableArrayPropertyPy(opt.branchRef, node.property) ?? `${opt.branchRef}.${node.property}`)
                 : `${opt.branchRef}.${node.property}`;
             return { guard: opt.guard, expr: linkExpr, lambdaBind: opt.lambdaBind };
         }
-        const linkExpr = isSharedPortableArrayProperty(node.property)
+        const linkExpr = !recordReceiver && isSharedPortableArrayProperty(node.property)
             ? (lowerPortableArrayPropertyPy(inner.expr, node.property) ?? `${inner.expr}.${node.property}`)
             : `${inner.expr}.${node.property}`;
         return { guard: inner.guard, expr: linkExpr, lambdaBind: inner.lambdaBind };
     }
     if (node.kind === 'index') {
         const obj = node.object;
+        const nested = nestedRecordFieldReceiverPy(obj, ctx);
+        if (nested !== null) {
+            if (node.optional)
+                throw new Error('portable: optional nested index access is outside the portable domain');
+            ctx.helpers.add(KERN_NESTED_ARRAY_HELPER_PY);
+            if (!isSafeIntegerLiteralIndex(node.index)) {
+                return {
+                    guard: null,
+                    expr: `_kern_nested_array_value(${nested.record}, ${JSON.stringify(nested.field)}, "__kern_invalid_index__")`,
+                };
+            }
+            const literalIndex = node.index;
+            return {
+                guard: null,
+                expr: `_kern_nested_array_value(${nested.record}, ${JSON.stringify(nested.field)}, ${literalIndex.raw})`,
+            };
+        }
+        const nonArrayNested = nestedRecordFieldNonArrayReceiverPy(obj, ctx);
+        if (nonArrayNested !== null) {
+            if (node.optional)
+                throw new Error('portable: optional nested index access is outside the portable domain');
+            ctx.helpers.add(KERN_NESTED_ARRAY_HELPER_PY);
+            if (!isSafeIntegerLiteralIndex(node.index)) {
+                return {
+                    guard: null,
+                    expr: `_kern_nested_array_value(${nonArrayNested.record}, ${JSON.stringify(nonArrayNested.field)}, "__kern_invalid_index__")`,
+                };
+            }
+            const literalIndex = node.index;
+            return {
+                guard: null,
+                expr: `_kern_nested_array_value(${nonArrayNested.record}, ${JSON.stringify(nonArrayNested.field)}, ${literalIndex.raw})`,
+            };
+        }
         // Slice 2 review fix — the bracket (`index`) form of a regex-literal
         // property access (`/x/["source"]`, `/x/["flags"]`, `/x/["test"](s)`)
         // launders the pattern/flags back to a string exactly like the dotted
@@ -2906,6 +3751,28 @@ function lowerChain(node, ctx) {
         throw new Error("Optional call '?.()' is not yet supported on Python target. " +
             'Bind the function reference to a `let` first, then test for `none` before calling.');
     }
+    // Nested-values slice-1 CHOKE POINT (lockstep with the TS call case's
+    // identical guard): ANY method call on a PROVEN record binding's array
+    // field fails closed BEFORE any per-method lowering (regex / lambda-array /
+    // portable-array) can admit it — the runner abstains on every such program.
+    if (node.callee.kind === 'member' && !node.callee.optional) {
+        const nestedRecv = nestedRecordFieldReceiverPy(node.callee.object, ctx);
+        if (nestedRecv !== null) {
+            ctx.helpers.add(KERN_NESTED_NO_PROPERTY_HELPER_PY);
+            return {
+                guard: null,
+                expr: `_kern_nested_no_property(${JSON.stringify(`${nestedRecv.record}.${nestedRecv.field}`)}, ${JSON.stringify(node.callee.property)})`,
+            };
+        }
+        const nonArrayNested = nestedRecordFieldNonArrayReceiverPy(node.callee.object, ctx);
+        if (nonArrayNested !== null) {
+            ctx.helpers.add(KERN_NESTED_NO_PROPERTY_HELPER_PY);
+            return {
+                guard: null,
+                expr: `_kern_nested_no_property(${JSON.stringify(`${nonArrayNested.record}.${nonArrayNested.field}`)}, ${JSON.stringify(node.callee.property)})`,
+            };
+        }
+    }
     // Slice 2a — KERN-stdlib dispatch must run on a top-level Module.method
     // call BEFORE we descend into the callee chain, so `Number.floor(x)`
     // doesn't degrade into a non-stdlib `Number.floor(x)` Python emit.
@@ -4407,7 +5274,9 @@ function emitExpressionV1Py(node, ctx) {
     declareLocalBinding(ctx, userName, 'const');
     const name = maybeRenameOnShadow(ctx, userName);
     setRegexBinding(ctx, userName, exprIR.kind === 'regexLit' ? exprIR : null);
-    const lines = [`${name} = ${emitPyExprCtx(exprIR, ctx)}`];
+    setRecordBinding(ctx, userName, exprIR.kind === 'objectLit', recordArrayFieldsForValue(exprIR, ctx), recordScalarArrayFieldsForValue(exprIR, ctx));
+    bindArrayStatusFromLet(ctx, userName, exprIR);
+    const lines = [`${name} = ${emitLetInitializerPy(exprIR, ctx)}`];
     if (ctx.traceHooks?.letAssign)
         lines.push(letAssignTracePy(name));
     return lines;