@kernlang/python 3.5.6 → 3.5.8-canary.204.1.43495cde

package/dist/fastapi-response.js

@@ -2,14 +2,10 @@
  * Response helpers for the FastAPI transpiler.
  *
  * generateRespondFastAPI — IR respond node → Python return/raise statements
- * rewriteFastAPIExpr    — rewrite portable request references to FastAPI equivalents
- * extractExprCode       — extract expression code from IR prop
  * addRespondImports     — add necessary imports for respond node
  */
-import { getProps, lowerJsClosureBodyToPython } from '@kernlang/core';
-import { KERN_I32_HELPER_PY, KERN_JS_HELPER_PY, KERN_TMOD_HELPER_PY } from './codegen-body-python.js';
-import { escapePyStr, quoteObjectKeysOutsideStrings } from './fastapi-utils.js';
-import { toSnakeCase } from './type-map.js';
+import { getProps } from '@kernlang/core';
+import { escapePyStr } from './fastapi-utils.js';
 export function generateRespondFastAPI(respondNode, indent) {
     const p = getProps(respondNode);
     const status = typeof p.status === 'number' ? p.status : undefined;
@@ -43,1971 +39,6 @@ export function generateRespondFastAPI(respondNode, indent) {
     }
     return [`${indent}return Response(status_code=200)`];
 }
-// Quoted strings absorbed by the alternation; only literal `===`/`!==`
-// outside strings get rewritten. Both single and double quotes AND
-// backtick template literals are covered so a message like
-// `` `use ===` `` is preserved (review fix — Codex+Gemini on 0ddfcc3d
-// flagged backticks as missing). Escape sequences are honored so
-// `"\""` / `` `\`` `` etc. don't terminate the string early.
-const STRING_LITERAL_ALT = '"(?:[^"\\\\]|\\\\.)*"|\'(?:[^\'\\\\]|\\\\.)*\'|`(?:[^`\\\\]|\\\\.)*`';
-const STRICT_EQ_RE = new RegExp(`${STRING_LITERAL_ALT}|===|!==`, 'g');
-// Same trick for JS-literal lowering: any literal text inside a quoted
-// string OR after a `.` (property accessor — `obj.true` must NOT become
-// `obj.True`, which is a Python SyntaxError) is preserved untouched.
-// Variable-width lookbehind `(?<!\.\s*)` handles both tight (`obj.true`)
-// and loose (`obj . true`) forms; the latter caught by Codex review on
-// commit 68565826.
-const JS_LITERAL_RE = new RegExp(`${STRING_LITERAL_ALT}|(?<!\\.\\s*)\\b(?:undefined|null|true|false)\\b`, 'g');
-// Within an arrow body/predicate, rewrite member access on the bound element
-// variable to dict-subscript form so iterating a list of dicts works at
-// runtime: `x.n` → `x["n"]`, `x.meta.tag` → `x["meta"]["tag"]`. A chain that is
-// immediately followed by `(` is a METHOD call (`x.toUpperCase()`) and is left
-// untouched for the string-method pass. String-aware (literal `"x.n"` is kept)
-// and skips a chain that is itself a property of something else (`body.x.n`).
-// Manual scan (no RegExp sticky matching) so single-char fields like `.n` are
-// handled — the prior regex required two-plus-char field names.
-function lowerDictMemberAccess(text, varName) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < text.length) {
-        const c = text[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += text[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const prev = text[i - 1];
-        const boundaryOk = !(prev && /[\w.$]/.test(prev));
-        const afterVar = text[i + varName.length] ?? '';
-        if (boundaryOk && text.startsWith(varName, i) && !/[\w$]/.test(afterVar)) {
-            let k = i + varName.length;
-            const fields = [];
-            while (text[k] === '.') {
-                const fm = text.slice(k + 1).match(/^[A-Za-z_$]\w*/);
-                if (!fm)
-                    break;
-                fields.push(fm[0]);
-                k += 1 + fm[0].length;
-            }
-            if (fields.length > 0) {
-                if (text[k] === '(') {
-                    // Method call: subscript the leading DATA fields but keep the final
-                    // segment as attribute access (the method name) so the string-method
-                    // / nested-array passes still see it — `x.name.toUpperCase()` →
-                    // `x["name"].toUpperCase()`, `x.tags.map(...)` → `x["tags"].map(...)`
-                    // (codex review of ab192611). A lone `x.method()` is unchanged.
-                    const dataFields = fields.slice(0, -1);
-                    const methodField = fields[fields.length - 1];
-                    out += `${varName + dataFields.map((field) => `[${JSON.stringify(field)}]`).join('')}.${methodField}`;
-                }
-                else {
-                    out += varName + fields.map((field) => `[${JSON.stringify(field)}]`).join('');
-                }
-                i = k;
-                continue;
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// A statement body that is EXACTLY `{ return E; }` is semantically identical to the
-// expression body `E`, so unwrap it to reuse the expression-bodied lowering (slice 1 of
-// native closures, #5). Richer statement bodies (locals, control flow, side effects
-// before the return) need full closure lowering (hoisted nested defs) and are NOT handled
-// here — they stay untouched (still unsupported) rather than mis-lowered. The scan is
-// string/bracket-aware so `{ return f({a:1}); }` unwraps but `{ return a; more(); }` does not.
-function unwrapSingleReturnBlock(body) {
-    const t = body.trim();
-    if (t.length < 2 || t[0] !== '{' || t[t.length - 1] !== '}')
-        return body;
-    const topLevelBreaks = (s, breakOnSemicolon) => {
-        let depth = 0;
-        let inStr = null;
-        for (let i = 0; i < s.length; i++) {
-            const c = s[i];
-            if (inStr) {
-                if (c === inStr && s[i - 1] !== '\\')
-                    inStr = null;
-                continue;
-            }
-            if (c === '"' || c === "'" || c === '`')
-                inStr = c;
-            else if (c === '{' || c === '(' || c === '[')
-                depth++;
-            else if (c === '}' || c === ')' || c === ']') {
-                depth--;
-                // the opening brace must match the FINAL char, else `{..}{..}` etc.
-                if (!breakOnSemicolon && depth === 0 && i !== s.length - 1)
-                    return true;
-            }
-            else if (breakOnSemicolon && c === ';' && depth === 0)
-                return true;
-        }
-        return false;
-    };
-    if (topLevelBreaks(t, false))
-        return body; // outer braces don't span the whole body
-    let inner = t.slice(1, -1).trim();
-    if (!/^return\b/.test(inner))
-        return body;
-    inner = inner.slice(6).trim();
-    if (inner.endsWith(';'))
-        inner = inner.slice(0, -1).trim();
-    if (!inner || topLevelBreaks(inner, true))
-        return body; // empty or multi-statement
-    return inner;
-}
-// Parse an arrow callback's argument text into `{ params, body }`, or null when
-// it isn't a single arrow function (e.g. `.map(fn)` with a bare reference, which
-// is left unchanged). Handles `(p) => body`, `p => body`, and `(p, i) => body`.
-function parseArrowCallback(inner) {
-    const trimmed = inner.trim();
-    if (trimmed.startsWith('(')) {
-        const close = matchBalancedParen(trimmed, 0);
-        if (close === -1)
-            return null;
-        const after = trimmed.slice(close + 1).trim();
-        if (!after.startsWith('=>'))
-            return null;
-        const params = splitTopLevelArgs(trimmed.slice(1, close))
-            .map((s) => s.trim())
-            .filter(Boolean);
-        return { params, body: unwrapSingleReturnBlock(after.slice(2).trim()) };
-    }
-    const m = trimmed.match(/^([A-Za-z_$][\w$]*)\s*=>\s*([\s\S]+)$/);
-    if (!m)
-        return null;
-    return { params: [m[1]], body: unwrapSingleReturnBlock(m[2].trim()) };
-}
-// Lower JS arrow-callback array methods to Python comprehensions:
-//   arr.filter((x) => pred)      -> [x for x in arr if pred]
-//   arr.map((x) => body)         -> [body for x in arr]
-//   arr.map((x, i) => body)      -> [body for i, x in enumerate(arr)]
-//   arr.find((x) => pred)        -> next((x for x in arr if pred), None)
-// Balanced + string-aware scan (NOT regex): the receiver is taken from the
-// already-emitted output via findReceiverStart, so chained calls compose
-// naturally (`arr.filter(...).map(...)` nests one comprehension inside the
-// next) and the quotes/brackets of a lowered comprehension can never desync the
-// receiver — the failure mode of the prior regex form. Member access on the
-// bound element is dict-subscripted so a list-of-dicts iterates correctly.
-const ARROW_ARRAY_METHODS = new Set(['filter', 'map', 'find', 'findIndex', 'findLast', 'findLastIndex', 'flatMap']);
-const PORTABLE_ARRAY_METHODS = new Set([
-    'includes',
-    'indexOf',
-    'join',
-    'slice',
-    'some',
-    'every',
-    'reduce',
-    'sort',
-    'flat',
-    'at',
-    'push',
-    'reverse',
-    'concat',
-    'fill',
-    'lastIndexOf',
-    'reduceRight',
-]);
-const LAMBDA_COLON_PLACEHOLDER = '__KERN_LAMBDA_COLON__';
-function lowerArrowBlockClosure(arrow, ctx) {
-    if (!arrow.body.trim().startsWith('{'))
-        return null;
-    const seq = ctx.closureSeq ?? { n: 0 };
-    const name = `__kern_closure_${seq.n++}`;
-    if (!ctx.closureSeq)
-        ctx.closureSeq = seq;
-    const result = lowerJsClosureBodyToPython(arrow.body, {
-        lowerExpression: (raw) => rewriteFastAPIExpr(lowerDictMemberAccess(raw, arrow.params[0]), ctx.pathParams, ctx.bodyFields, ctx.authUser, ctx.imports, undefined, ctx.closureSeq),
-        lowerCondition: (raw) => `js_truthy(${rewriteFastAPIExpr(lowerDictMemberAccess(raw, arrow.params[0]), ctx.pathParams, ctx.bodyFields, ctx.authUser, ctx.imports, undefined, ctx.closureSeq)})`,
-    });
-    if (!result.ok)
-        return null;
-    ctx.imports?.add(KERN_JS_HELPER_PY);
-    const params = arrow.params.join(', ');
-    const def = [`def ${name}(${params}):`, ...(result.lines.length > 0 ? result.lines : ['    pass'])].join('\n');
-    if (ctx.hoistedDefs) {
-        ctx.hoistedDefs.push(def);
-    }
-    else {
-        ctx.imports?.add(def);
-    }
-    return `${name}(${arrow.params.join(', ')})`;
-}
-function lowerJsArrayMethods(expr, ctx) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr.slice(i).match(/^\.([A-Za-z]\w*)\(/);
-        if (m && ARROW_ARRAY_METHODS.has(m[1])) {
-            const method = m[1];
-            const openIdx = i + m[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            const recvStart = findReceiverStart(out);
-            if (closeIdx !== -1 && recvStart !== -1) {
-                const arrow = parseArrowCallback(expr.slice(openIdx + 1, closeIdx));
-                if (arrow && arrow.params.length >= 1) {
-                    const receiver = out.slice(recvStart);
-                    const pre = out.slice(0, recvStart);
-                    const elemVar = arrow.params[0];
-                    const idxVar = arrow.params[1];
-                    // Recurse for nested array methods in the body; subscript the element
-                    // var's member access. The index var (if any) stays a bare int.
-                    const blockClosure = lowerArrowBlockClosure(arrow, ctx);
-                    const body = blockClosure ?? lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), ctx);
-                    // A second callback param is the element index — bind it via
-                    // enumerate() for every method, not just map, so a predicate that
-                    // references the index (`(x, i) => i > 0`) doesn't emit an unbound
-                    // name (codex review of ab192611).
-                    const loopTarget = idxVar ? `${idxVar}, ${elemVar}` : elemVar;
-                    const source = idxVar ? `enumerate(${receiver})` : receiver;
-                    let lowered;
-                    if (method === 'filter') {
-                        lowered = `[${elemVar} for ${loopTarget} in ${source} if ${body}]`;
-                    }
-                    else if (method === 'find') {
-                        lowered = `next((${elemVar} for ${loopTarget} in ${source} if ${body}), None)`;
-                    }
-                    else if (method === 'findIndex') {
-                        // index of the first match, or -1 (never raises). Bind the user's
-                        // own index var when the callback has one, so `(x, i) => …i…` works.
-                        const ix = idxVar ?? '__i';
-                        lowered = `next((${ix} for ${ix}, ${elemVar} in enumerate(${receiver}) if ${body}), -1)`;
-                    }
-                    else if (method === 'findLast') {
-                        // last matching element, or None
-                        lowered = idxVar
-                            ? `next((${elemVar} for ${idxVar}, ${elemVar} in reversed(list(enumerate(${receiver}))) if ${body}), None)`
-                            : `next((${elemVar} for ${elemVar} in reversed(${receiver}) if ${body}), None)`;
-                    }
-                    else if (method === 'findLastIndex') {
-                        // index of the last match, or -1
-                        const ix = idxVar ?? '__i';
-                        lowered = `next((${ix} for ${ix}, ${elemVar} in reversed(list(enumerate(${receiver}))) if ${body}), -1)`;
-                    }
-                    else 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.
-                        lowered = `[__y for ${loopTarget} in ${source} for __y in (${body} if isinstance(${body}, list) else [${body}])]`;
-                    }
-                    else {
-                        lowered = `[${body} for ${loopTarget} in ${source}]`;
-                    }
-                    out = `${pre}${lowered}`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        const mArray = expr.slice(i).match(/^\.([A-Za-z]\w*)\(/);
-        if (mArray && PORTABLE_ARRAY_METHODS.has(mArray[1])) {
-            const method = mArray[1];
-            const openIdx = i + mArray[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            const recvStart = findReceiverStart(out);
-            if (closeIdx !== -1 && recvStart !== -1) {
-                const receiver = out.slice(recvStart);
-                const pre = out.slice(0, recvStart);
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerJsArrayMethods(a.trim(), ctx));
-                let lowered = null;
-                if (method === 'includes') {
-                    const needle = args[0] ?? '';
-                    lowered = `(${needle} in ${receiver})`;
-                }
-                else if (method === 'indexOf') {
-                    const needle = args[0] ?? '';
-                    const fromIndex = args[1] ?? null;
-                    if (fromIndex) {
-                        lowered = `(next((__i for __i, __v in enumerate(${receiver}) if __i >= ${fromIndex} and __v == ${needle}), -1))`;
-                    }
-                    else {
-                        lowered = `(next((__i for __i, __v in enumerate(${receiver}) if __v == ${needle}), -1))`;
-                    }
-                }
-                else if (method === 'push') {
-                    // JS Array.push mutates AND returns the new length. Python list.append
-                    // returns None, so emit `(recv.append(x) or len(recv))` for exact parity
-                    // (mutate + length). Single-arg only; varargs push left unsupported.
-                    if (args.length === 1)
-                        lowered = `(${receiver}.append(${args[0]}) or len(${receiver}))`;
-                }
-                else if (method === 'reverse') {
-                    // JS Array.reverse mutates AND returns the (same, reversed) array; Python
-                    // list.reverse returns None -> `(recv.reverse() or recv)` mutates + returns it.
-                    lowered = `(${receiver}.reverse() or ${receiver})`;
-                }
-                else if (method === 'concat') {
-                    // JS Array.concat returns a NEW array; an array arg is spread, a scalar arg
-                    // is appended. Mirror with `recv + (x if isinstance(x, list) else [x])`.
-                    // Single-arg only; varargs concat left unsupported.
-                    if (args.length === 1)
-                        lowered = `(${receiver} + (${args[0]} if isinstance(${args[0]}, list) else [${args[0]}]))`;
-                }
-                else if (method === 'join') {
-                    const sep = args[0] ?? '","';
-                    lowered = `${sep}.join(str(__v) for __v in ${receiver})`;
-                }
-                else if (method === 'slice') {
-                    const start = args[0];
-                    const end = args[1];
-                    if (!start && !end)
-                        lowered = `${receiver}[:]`;
-                    else if (start && !end)
-                        lowered = `${receiver}[${start}:]`;
-                    else if (!start && end)
-                        lowered = `${receiver}[:${end}]`;
-                    else
-                        lowered = `${receiver}[${start}:${end}]`;
-                }
-                else if (method === 'some' || method === 'every') {
-                    const arrow = parseArrowCallback(expr.slice(openIdx + 1, closeIdx));
-                    if (arrow && arrow.params.length >= 1) {
-                        const elemVar = arrow.params[0];
-                        const idxVar = arrow.params[1];
-                        // Only the element var is dict-subscripted; the index var stays a
-                        // bare int and must be bound via enumerate() when present.
-                        const blockClosure = lowerArrowBlockClosure(arrow, ctx);
-                        const pred = blockClosure ?? lowerJsArrayMethods(lowerDictMemberAccess(arrow.body, elemVar), ctx);
-                        const loopTarget = idxVar ? `${idxVar}, ${elemVar}` : elemVar;
-                        const source = idxVar ? `enumerate(${receiver})` : receiver;
-                        lowered =
-                            method === 'some'
-                                ? `any(${pred} for ${loopTarget} in ${source})`
-                                : `all(${pred} for ${loopTarget} in ${source})`;
-                    }
-                }
-                else if (method === 'reduce') {
-                    const rawArgs = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                    const arrow = parseArrowCallback(rawArgs[0] ?? '');
-                    if (arrow && arrow.params.length >= 2) {
-                        const accVar = arrow.params[0];
-                        const elemVar = arrow.params[1];
-                        let body = lowerDictMemberAccess(arrow.body, accVar);
-                        body = lowerDictMemberAccess(body, elemVar);
-                        const loweredBody = lowerJsArrayMethods(body, ctx);
-                        ctx.imports?.add('import functools');
-                        if (rawArgs.length >= 2) {
-                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), ctx);
-                            lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver}, ${seed})`;
-                        }
-                        else {
-                            lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver})`;
-                        }
-                    }
-                }
-                else if (method === 'reduceRight') {
-                    // reduce from the right: same callback (acc, cur), reversed sequence.
-                    const rawArgs = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                    const arrow = parseArrowCallback(rawArgs[0] ?? '');
-                    if (arrow && arrow.params.length >= 2) {
-                        const accVar = arrow.params[0];
-                        const elemVar = arrow.params[1];
-                        let body = lowerDictMemberAccess(arrow.body, accVar);
-                        body = lowerDictMemberAccess(body, elemVar);
-                        const loweredBody = lowerJsArrayMethods(body, ctx);
-                        ctx.imports?.add('import functools');
-                        if (rawArgs.length >= 2) {
-                            const seed = lowerJsArrayMethods(rawArgs[1].trim(), ctx);
-                            lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver}[::-1], ${seed})`;
-                        }
-                        else {
-                            lowered = `functools.reduce(lambda ${accVar}, ${elemVar}${LAMBDA_COLON_PLACEHOLDER} ${loweredBody}, ${receiver}[::-1])`;
-                        }
-                    }
-                }
-                else if (method === 'sort') {
-                    // JS default sort is LEXICOGRAPHIC and returns a NEW array (Python's
-                    // list.sort() is numeric AND in-place → None). A 2-arg comparator
-                    // sorts numerically; anything else falls back to the string key.
-                    const arrow = parseArrowCallback(expr.slice(openIdx + 1, closeIdx));
-                    if (arrow && arrow.params.length >= 2) {
-                        const a = arrow.params[0];
-                        const b = arrow.params[1];
-                        const body = lowerJsArrayMethods(arrow.body, ctx);
-                        ctx.imports?.add('import functools');
-                        lowered = `sorted(${receiver}, key=functools.cmp_to_key(lambda ${a}, ${b}${LAMBDA_COLON_PLACEHOLDER} ${body}))`;
-                    }
-                    else {
-                        lowered = `sorted(${receiver}, key=lambda __v${LAMBDA_COLON_PLACEHOLDER} str(__v))`;
-                    }
-                }
-                else if (method === 'flat') {
-                    // one level: flatten nested lists, keep scalars
-                    lowered = `[__y for __x in ${receiver} for __y in (__x if isinstance(__x, list) else [__x])]`;
-                }
-                else if (method === 'at') {
-                    const n = args[0] ?? '0';
-                    lowered = `(${receiver}[${n}] if -len(${receiver}) <= ${n} < len(${receiver}) else None)`;
-                    // NB: `reverse` and `concat` are handled earlier in this chain (they mutate /
-                    // accept scalar args per JS) — main's later array-only duplicates were dropped
-                    // in the roadmap-stack merge (they were dead + concat broke on scalar args).
-                }
-                else if (method === 'fill') {
-                    const v = args[0] ?? 'None';
-                    if (args.length <= 1) {
-                        lowered = `[${v} for __ in ${receiver}]`;
-                    }
-                    else {
-                        // fill(value, start, end) fills [start, end) with JS negative-index
-                        // normalization; untouched positions keep their original element.
-                        const s = args[1];
-                        const e = args[2] ?? `len(${receiver})`;
-                        lowered = `[(${v} if (${s} if ${s} >= 0 else ${s} + len(${receiver})) <= __i < (${e} if ${e} >= 0 else ${e} + len(${receiver})) else __x) for __i, __x in enumerate(${receiver})]`;
-                    }
-                }
-                else if (method === 'lastIndexOf') {
-                    const needle = args[0] ?? '';
-                    // String receivers use rfind (correct for multi-char substrings, -1
-                    // when absent); array receivers reverse-scan by element equality.
-                    lowered = `(${receiver}.rfind(${needle}) if isinstance(${receiver}, str) else (len(${receiver}) - 1 - ${receiver}[::-1].index(${needle}) if ${needle} in ${receiver} else -1))`;
-                }
-                if (lowered) {
-                    out = `${pre}${lowered}`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Index of the bracket that closes the one at `openIdx`, tracking ()[]{} depth
-// and skipping string/template literals. -1 if unbalanced.
-function matchBalancedParen(expr, openIdx) {
-    let depth = 0;
-    let quote = null;
-    for (let i = openIdx; i < expr.length; i++) {
-        const c = expr[i];
-        if (quote) {
-            if (c === '\\')
-                i += 1;
-            else if (c === quote)
-                quote = null;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`')
-            quote = c;
-        else if (c === '(' || c === '[' || c === '{')
-            depth += 1;
-        else if (c === ')' || c === ']' || c === '}') {
-            depth -= 1;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-// Split a call's inner argument text on top-level commas, ignoring commas
-// inside nested ()[]{} or string literals.
-function splitTopLevelArgs(inner) {
-    const args = [];
-    let depth = 0;
-    let quote = null;
-    let start = 0;
-    for (let i = 0; i < inner.length; i++) {
-        const c = inner[i];
-        if (quote) {
-            if (c === '\\')
-                i += 1;
-            else if (c === quote)
-                quote = null;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`')
-            quote = c;
-        else if (c === '(' || c === '[' || c === '{')
-            depth += 1;
-        else if (c === ')' || c === ']' || c === '}')
-            depth -= 1;
-        else if (c === ',' && depth === 0) {
-            args.push(inner.slice(start, i).trim());
-            start = i + 1;
-        }
-    }
-    args.push(inner.slice(start).trim());
-    return args;
-}
-// Lower JSON.stringify(...) / JSON.parse(...) to json.dumps/loads. Uses a
-// balanced, string-aware scan because the single argument can itself contain
-// commas, nested parens, brackets, braces, or string literals — which regex
-// cannot reliably capture (three regex iterations were each holed by review).
-// Skips occurrences inside string literals and those that are a property of
-// another receiver (e.g. `myJSON.stringify`). Handles the pretty-print form
-// `JSON.stringify(x, null, n)` → `json.dumps(x, indent=n)`.
-function lowerJsonBuiltinCalls(expr, imports) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr.slice(i).match(/^JSON\.(stringify|parse)\(/);
-        const prev = expr[i - 1];
-        if (m && !(prev && /[\w.]/.test(prev))) {
-            const method = m[1];
-            const openIdx = i + m[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                // Recurse so a nested builtin in the argument is lowered too, e.g.
-                // JSON.stringify(JSON.parse(x)) → json.dumps(json.loads(x)) (Codex
-                // review on 9d8ed8d0). Terminates: the argument is strictly shorter.
-                const a0 = lowerJsonBuiltinCalls(args[0] ?? '', imports);
-                imports?.add('import json');
-                if (method === 'parse') {
-                    out += `json.loads(${a0})`;
-                }
-                else if (args.length >= 3 && /^(None|null)$/.test(args[1]) && /^\d+$/.test(args[2])) {
-                    out += `json.dumps(${a0}, indent=${args[2]})`;
-                }
-                else {
-                    out += `json.dumps(${a0})`;
-                }
-                i = closeIdx + 1;
-                continue;
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Lower Number/Math arithmetic builtins used in portable expressions.
-// String-aware + balanced-paren scan, so nested calls/expressions survive:
-//   Number.floor(a + b) -> __k_math.floor(a + b)
-//   Number.round(x)     -> __k_math.floor(x + 0.5)  (JS Math.round parity)
-//   Math.max(a, b, c)   -> max(a, b, c)
-// Guards skip member calls on custom receivers (e.g. myNumber.floor(x)).
-function lowerMathBuiltinCalls(expr, imports) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr
-            .slice(i)
-            .match(/^(?:(?:Number|Math)\.(floor|ceil|round|abs|trunc|isFinite|isNaN)|Math\.(min|max|pow|sqrt|hypot|random|sign|log10|log2|log|exp|sin|cos|atan2))\(/);
-        const prev = expr[i - 1];
-        // Math.PI / Math.E are constants (no call), so the call regex never sees
-        // them — handle them here before the method dispatch.
-        const cm = expr.slice(i).match(/^Math\.(PI|E)\b/);
-        if (cm && !(prev && /[\w.]/.test(prev))) {
-            imports?.add('import math as __k_math');
-            out += cm[1] === 'PI' ? '__k_math.pi' : '__k_math.e';
-            i += cm[0].length;
-            continue;
-        }
-        if (m && !(prev && /[\w.]/.test(prev))) {
-            const method = m[1] ?? m[2];
-            const openIdx = i + m[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const inner = expr.slice(openIdx + 1, closeIdx);
-                const rawArgs = inner.trim() === '' ? [] : splitTopLevelArgs(inner);
-                const loweredArgs = rawArgs.map((a) => lowerMathBuiltinCalls(a, imports).trim());
-                const arg = loweredArgs[0] ?? '';
-                switch (method) {
-                    case 'floor':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.floor(${arg})`;
-                        break;
-                    case 'ceil':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.ceil(${arg})`;
-                        break;
-                    case 'round':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.floor(${arg} + 0.5)`;
-                        break;
-                    case 'abs':
-                        out += `abs(${arg})`;
-                        break;
-                    case 'trunc':
-                        // JS Math.trunc truncates toward zero; math.trunc matches.
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.trunc(${arg})`;
-                        break;
-                    case 'isFinite':
-                        imports?.add('import math as __k_math');
-                        // Type guard: Number.isFinite returns false for non-numbers; math.isfinite raises TypeError
-                        out += `(isinstance(${arg}, (int, float)) and __k_math.isfinite(${arg}))`;
-                        break;
-                    case 'isNaN':
-                        imports?.add('import math as __k_math');
-                        // Type guard: Number.isNaN returns false for non-numbers; math.isnan raises TypeError
-                        out += `(isinstance(${arg}, (int, float)) and __k_math.isnan(${arg}))`;
-                        break;
-                    case 'min':
-                        // JS Math.min(): 0 args → +Infinity; 1 arg → that value (Python
-                        // min(x) treats a lone arg as an iterable and raises).
-                        if (loweredArgs.length === 0)
-                            out += 'float("inf")';
-                        else if (loweredArgs.length === 1)
-                            out += `(${arg})`;
-                        else
-                            out += `min(${loweredArgs.join(', ')})`;
-                        break;
-                    case 'max':
-                        if (loweredArgs.length === 0)
-                            out += 'float("-inf")';
-                        else if (loweredArgs.length === 1)
-                            out += `(${arg})`;
-                        else
-                            out += `max(${loweredArgs.join(', ')})`;
-                        break;
-                    case 'pow':
-                        // JS Math.pow(a, b) === a ** b; fewer than 2 args is NaN in JS.
-                        out += loweredArgs.length >= 2 ? `(${loweredArgs[0]} ** ${loweredArgs[1]})` : 'float("nan")';
-                        break;
-                    case 'sqrt':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.sqrt(${arg})`;
-                        break;
-                    case 'hypot':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.hypot(${loweredArgs.join(', ')})`;
-                        break;
-                    case 'random':
-                        imports?.add('import random as __k_random');
-                        out += '__k_random.random()';
-                        break;
-                    case 'sign':
-                        // JS Math.sign returns -1, 0, or 1; 0 args → NaN.
-                        out += loweredArgs.length === 0 ? 'float("nan")' : `(1 if ${arg} > 0 else (-1 if ${arg} < 0 else 0))`;
-                        break;
-                    // Math.cbrt is intentionally NOT lowered: V8's Math.cbrt and the
-                    // platform libm cbrt disagree in the last ulp (Linux: cbrt(27) =
-                    // 3.0000000000000004, V8 = 3), so no Python expression reproduces it
-                    // bit-for-bit — same out-of-scope reason as toPrecision.
-                    case 'log':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.log(${arg})`;
-                        break;
-                    case 'log2':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.log2(${arg})`;
-                        break;
-                    case 'log10':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.log10(${arg})`;
-                        break;
-                    case 'exp':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.exp(${arg})`;
-                        break;
-                    case 'sin':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.sin(${arg})`;
-                        break;
-                    case 'cos':
-                        imports?.add('import math as __k_math');
-                        out += `__k_math.cos(${arg})`;
-                        break;
-                    case 'atan2':
-                        // JS Math.atan2(y, x) needs BOTH args; fewer → NaN.
-                        imports?.add('import math as __k_math');
-                        out += loweredArgs.length >= 2 ? `__k_math.atan2(${loweredArgs[0]}, ${loweredArgs[1]})` : 'float("nan")';
-                        break;
-                    default:
-                        out += expr.slice(i, closeIdx + 1);
-                        break;
-                }
-                i = closeIdx + 1;
-                continue;
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Find the start of the JS expression that ends just before the current position.
-// Uses a balanced-scan (backwards) to skip over () [] {}.
-function findReceiverStart(s) {
-    let j = s.length - 1;
-    while (j >= 0 && /\s/.test(s[j]))
-        j--;
-    if (j < 0)
-        return -1;
-    let depth = 0;
-    while (j >= 0) {
-        const c = s[j];
-        if (c === '"' || c === "'" || c === '`') {
-            // A string literal is one atom — scan back to its matching open quote,
-            // honoring backslash escapes, so `"a.b(".charAt(1)` or `data["k"].at(0)`
-            // don't desync the receiver. (The old scan stopped AT the quote, leaving
-            // an empty receiver and emitting broken Python.)
-            const q = c;
-            let k = j - 1;
-            while (k >= 0) {
-                if (s[k] === q) {
-                    let b = 0;
-                    let p = k - 1;
-                    while (p >= 0 && s[p] === '\\') {
-                        b++;
-                        p--;
-                    }
-                    if (b % 2 === 0)
-                        break;
-                }
-                k--;
-            }
-            if (depth === 0)
-                return k < 0 ? 0 : k; // the literal is the receiver atom
-            j = k - 1; // literal sits inside brackets — skip it and keep scanning
-            continue;
-        }
-        if (c === ')' || c === ']' || c === '}') {
-            depth++;
-        }
-        else if (c === '(' || c === '[' || c === '{') {
-            depth--;
-            if (depth < 0)
-                return j + 1;
-        }
-        else if (depth === 0) {
-            // At top level, we stop at anything that isn't part of an identifier,
-            // property access, or indexed access.
-            if (!/[\w.$]/.test(c))
-                return j + 1;
-        }
-        j--;
-    }
-    return 0;
-}
-// Lower Number parsing and formatting builtins:
-//   parseInt(x) / parseInt(x, 10) -> int(x)
-//   parseFloat(x)                 -> float(x)
-//   Number.isInteger(x)           -> (isinstance(x, int) and not isinstance(x, bool))
-//   Number(x)                     -> float(x)  (best-effort coercion)
-//   (n).toFixed(d)                -> f"{n:.{d}f}"
-// String-aware + balanced-paren scan so nested calls survive.
-function lowerNumberBuiltinCalls(expr, imports) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr
-            .slice(i)
-            .match(/^(?:Number\.isInteger|Number\.isSafeInteger|Number\.parseInt|Number\.parseFloat|Number|parseInt|parseFloat|isNaN|isFinite)\(/);
-        const prev = expr[i - 1];
-        if (m && !(prev && /[\w.]/.test(prev))) {
-            const match = m[0];
-            const method = match.slice(0, -1);
-            const openIdx = i + match.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const inner = expr.slice(openIdx + 1, closeIdx);
-                const args = splitTopLevelArgs(inner);
-                const a0 = lowerNumberBuiltinCalls(args[0] ?? '', imports).trim();
-                if (method === 'parseInt' || method === 'Number.parseInt') {
-                    if (args.length === 1 || (args.length === 2 && args[1].trim() === '10')) {
-                        out += `int(${a0})`;
-                    }
-                    else {
-                        const a1 = args[1] ? lowerNumberBuiltinCalls(args[1], imports).trim() : '';
-                        out += `int(${a0}, ${a1})`;
-                    }
-                }
-                else if (method === 'parseFloat' || method === 'Number.parseFloat') {
-                    out += `float(${a0})`;
-                }
-                else if (method === 'Number.isInteger') {
-                    out += `(isinstance(${a0}, int) and not isinstance(${a0}, bool))`;
-                }
-                else if (method === 'Number.isSafeInteger') {
-                    // JS: an integer-valued finite number within ±(2^53 − 1). Whole floats
-                    // count too; bool is not a number on the JS side.
-                    imports?.add('import math as __k_math');
-                    out += `(isinstance(${a0}, (int, float)) and not isinstance(${a0}, bool) and __k_math.isfinite(${a0}) and __k_math.floor(${a0}) == ${a0} and abs(${a0}) <= 9007199254740991)`;
-                }
-                else if (method === 'isNaN') {
-                    // GLOBAL isNaN (not Number.isNaN) — numeric inputs only (full JS
-                    // string-coercion is out of scope); raises on non-numbers.
-                    imports?.add('import math as __k_math');
-                    out += `__k_math.isnan(${a0})`;
-                }
-                else if (method === 'isFinite') {
-                    imports?.add('import math as __k_math');
-                    out += `__k_math.isfinite(${a0})`;
-                }
-                else if (method === 'Number') {
-                    out += `float(${a0})`;
-                }
-                i = closeIdx + 1;
-                continue;
-            }
-        }
-        if (expr.startsWith('.toFixed(', i)) {
-            const openIdx = i + '.toFixed('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const inner = expr.slice(openIdx + 1, closeIdx);
-                const args = splitTopLevelArgs(inner);
-                const precision = args[0] ? lowerNumberBuiltinCalls(args[0], imports).trim() : '0';
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1) {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    // Quote-safe: a nested f-string `f"{receiver:.{p}f}"` is a SyntaxError
-                    // on CPython <3.12 when the receiver contains `"` (e.g. data["k"]).
-                    // `format(x, '.' + str(p) + 'f')` keeps the receiver as a bare arg.
-                    out = `${pre}format(${receiver}, '.' + str(${precision}) + 'f')`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        // (n).toString(radix) → format/str. Only the explicit radix form is lowered
-        // (radix 2/8/16 via format spec, 10 via str); a no-arg .toString() is left
-        // raw because on a non-number receiver it would mean the wrong thing.
-        if (expr.startsWith('.toString(', i)) {
-            const openIdx = i + '.toString('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                const radix = (args[0] ?? '').trim();
-                const spec = radix === '2' ? 'b' : radix === '8' ? 'o' : radix === '16' ? 'x' : null;
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1 && (spec || radix === '10')) {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    out = spec ? `${pre}format(${receiver}, '${spec}')` : `${pre}str(${receiver})`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        // (n).toExponential(d) → '%.<d>e' then strip the leading zero(s) JS omits in
-        // the exponent: Python gives 1.23e+03, JS gives 1.23e+3.
-        if (expr.startsWith('.toExponential(', i)) {
-            const openIdx = i + '.toExponential('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                const digits = args[0] ? lowerNumberBuiltinCalls(args[0], imports).trim() : '';
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1 && digits !== '') {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    imports?.add('import re as __k_re');
-                    out = `${pre}__k_re.sub(r"e([+-])0*(\\d)", r"e\\1\\2", ('%.' + str(${digits}) + 'e') % (${receiver}))`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Lower JS string builtins to Python methods:
-//   x.toUpperCase() -> x.upper()
-//   x.toLowerCase() -> x.lower()
-//   x.trim()        -> x.strip()
-//   x.padStart(n[, fill]) -> x.rjust(n[, fill])  (JS/Python both default to " ")
-//   x.padEnd(n[, fill])   -> x.ljust(n[, fill])
-// Skip string literals so text like "a.toUpperCase()" / ".padStart(" stays raw.
-// pad*/startsWith/endsWith take args, so only the method+`(` is matched and the
-// argument list flows through to Python unchanged. Note: JS pad* accept a
-// multi-char fill while Python rjust/ljust require a single fill char — only the
-// 1-char fixture form is in scope; a multi-char fill is left to raise on Python.
-function lowerStringBuiltinCalls(expr) {
-    return expr.replace(new RegExp(`${STRING_LITERAL_ALT}|\\.toUpperCase\\(\\)|\\.toLowerCase\\(\\)|\\.trim\\(\\)|\\.startsWith\\(|\\.endsWith\\(|\\.padStart\\(|\\.padEnd\\(`, 'g'), (match) => {
-        if (match === '.toUpperCase()')
-            return '.upper()';
-        if (match === '.toLowerCase()')
-            return '.lower()';
-        if (match === '.trim()')
-            return '.strip()';
-        // startsWith/endsWith take args; match only the method+`(` so the
-        // argument list passes through to Python's str.startswith/endswith.
-        if (match === '.startsWith(')
-            return '.startswith(';
-        if (match === '.endsWith(')
-            return '.endswith(';
-        if (match === '.padStart(')
-            return '.rjust(';
-        if (match === '.padEnd(')
-            return '.ljust(';
-        return match;
-    });
-}
-// Lower the argument-taking JS String methods that need more than a bare method
-// rename (those are handled by lowerStringBuiltinCalls). One string-aware,
-// balanced scan reused for all of them; the shared matchBalancedParen /
-// splitTopLevelArgs / findReceiverStart helpers carve out args and receiver so
-// no new char-loop matcher is introduced:
-//   s.replace("a", "b")  -> s.replace("a", "b", 1)   (JS replaces FIRST only,
-//                            Python str.replace replaces ALL — pin count=1)
-//   s.substring(a, b)    -> s[a:b]      (and s.substring(a) -> s[a:])
-//   s.repeat(n)          -> (s * n)
-//   s.split(sep, limit)  -> s.split(sep)[:limit]      THE TRAP: Python's 2nd
-//                            arg is maxsplit, which KEEPS the remainder; JS
-//                            keeps only the first `limit` parts. The no-limit
-//                            s.split(sep) form is left raw (Python matches JS).
-// replace: only the 2-arg, non-regex form is lowered (`s.replace(/re/, b)` is
-// out of scope); `.replaceAll(` never matches. A quoted `".repeat("` etc. is
-// skipped by the quote tracking, so string-literal text stays raw.
-// substring edge (scoped out): JS substring clamps negative args to 0 and SWAPS
-// them when a > b; Python slicing does neither. Only the simple non-negative
-// fixture case is lowered — a negative/swapped substring would diverge.
-function lowerStringArgMethods(expr) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        if (expr.startsWith('.replaceAll(', i)) {
-            const openIdx = i + '.replaceAll('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                if (args.length === 2 && !args[0].trim().startsWith('/')) {
-                    const a0 = lowerStringArgMethods(args[0]).trim();
-                    const a1 = lowerStringArgMethods(args[1]).trim();
-                    // Python str.replace already replaces ALL occurrences (no count arg).
-                    out += `.replace(${a0}, ${a1})`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        if (expr.startsWith('.replace(', i)) {
-            const openIdx = i + '.replace('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx));
-                if (args.length === 2 && !args[0].trim().startsWith('/')) {
-                    const a0 = lowerStringArgMethods(args[0]).trim();
-                    const a1 = lowerStringArgMethods(args[1]).trim();
-                    out += `.replace(${a0}, ${a1}, 1)`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        // trimStart/trimEnd → lstrip/rstrip (method→method, receiver trails in `out`).
-        if (expr.startsWith('.trimStart()', i)) {
-            out += '.lstrip()';
-            i += '.trimStart()'.length;
-            continue;
-        }
-        if (expr.startsWith('.trimEnd()', i)) {
-            out += '.rstrip()';
-            i += '.trimEnd()'.length;
-            continue;
-        }
-        // charAt(i) → char or "" out of range (JS never raises; negative → "").
-        if (expr.startsWith('.charAt(', i)) {
-            const openIdx = i + '.charAt('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerStringArgMethods(a).trim());
-                const idx = args[0] ?? '0';
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1) {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    out = `${pre}(${receiver}[${idx}] if 0 <= ${idx} < len(${receiver}) else "")`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        // charCodeAt(i)/codePointAt(i) → ord of the char (in-range; BMP only).
-        if (expr.startsWith('.charCodeAt(', i) || expr.startsWith('.codePointAt(', i)) {
-            const tok = expr.startsWith('.charCodeAt(', i) ? '.charCodeAt(' : '.codePointAt(';
-            const openIdx = i + tok.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerStringArgMethods(a).trim());
-                const idx = args[0] ?? '0';
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1) {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    // JS charCodeAt/codePointAt never raise: out-of-range (incl. negative)
-                    // → NaN/undefined, which both become JSON null. Guard to avoid IndexError.
-                    out = `${pre}(ord(${receiver}[${idx}]) if 0 <= ${idx} < len(${receiver}) else None)`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        if (expr.startsWith('.substring(', i)) {
-            const openIdx = i + '.substring('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                // Receiver is already in `out`; `s.substring(a, b)` and `s[a:b]` both
-                // trail the receiver, so just append the slice — no receiver surgery.
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerStringArgMethods(a).trim());
-                const start = args[0] ?? '';
-                const end = args[1] ?? '';
-                out += `[${start}:${end}]`;
-                i = closeIdx + 1;
-                continue;
-            }
-        }
-        if (expr.startsWith('.repeat(', i)) {
-            const openIdx = i + '.repeat('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerStringArgMethods(a).trim());
-                const n = args[0] ?? '0';
-                const receiverStart = findReceiverStart(out);
-                if (receiverStart !== -1) {
-                    const receiver = out.slice(receiverStart);
-                    const pre = out.slice(0, receiverStart);
-                    out = `${pre}(${receiver} * ${n})`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        if (expr.startsWith('.split(', i)) {
-            const openIdx = i + '.split('.length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const args = splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)).map((a) => lowerStringArgMethods(a).trim());
-                // Only the 2-arg limit form needs rewriting; the no-limit form is left
-                // raw (falls through) because Python str.split(sep) already matches JS.
-                if (args.length === 2) {
-                    out += `.split(${args[0]})[:${args[1]}]`;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Lower selected Object/Array/Date host builtins in portable expressions:
-//   Object.keys(x)       -> list(x.keys())
-//   Object.values(x)     -> list(x.values())
-//   Object.entries(x)    -> list(x.items())
-//   Object.assign(t,s,…) -> {**t, **s, ...}
-//   Object.fromEntries(p) -> dict(p)
-//   Array.isArray(x)     -> isinstance(x, list)
-//   Date.now()           -> int(datetime.now(timezone.utc).timestamp() * 1000)
-// Uses the same string-aware balanced scan as other builtin lowerers.
-function lowerObjectArrayDateBuiltinCalls(expr, imports) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr
-            .slice(i)
-            .match(/^(Object\.(keys|values|entries|assign|fromEntries)|Array\.(isArray|of)|String\.fromCharCode)\(/);
-        const prev = expr[i - 1];
-        if (m && !(prev && /[\w.]/.test(prev))) {
-            const method = m[1];
-            const openIdx = i + m[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1) {
-                const rawArgs = expr.slice(openIdx + 1, closeIdx);
-                if (method === 'Object.assign') {
-                    const args = splitTopLevelArgs(rawArgs)
-                        .map((a) => lowerObjectArrayDateBuiltinCalls(a, imports).trim())
-                        .filter(Boolean);
-                    if (args.length >= 1) {
-                        // The request `body` is a Pydantic BaseModel, not a mapping, so
-                        // `{**body}` raises TypeError. Unpack its dict form instead.
-                        out += `{${args.map((a) => (a === 'body' ? '**body.model_dump()' : `**${a}`)).join(', ')}}`;
-                    }
-                    else {
-                        out += '{}';
-                    }
-                }
-                else if (method === 'Object.fromEntries') {
-                    const arg = lowerObjectArrayDateBuiltinCalls(rawArgs, imports).trim();
-                    out += `dict(${arg})`;
-                }
-                else if (method === 'Array.of') {
-                    // Array.of(...items) is a plain list of its args (NOT Array(n) length).
-                    const args = rawArgs.trim() === ''
-                        ? []
-                        : splitTopLevelArgs(rawArgs).map((a) => lowerObjectArrayDateBuiltinCalls(a, imports).trim());
-                    out += `[${args.join(', ')}]`;
-                }
-                else if (method === 'String.fromCharCode') {
-                    // chr() per code unit; join when there are several.
-                    const args = rawArgs.trim() === ''
-                        ? []
-                        : splitTopLevelArgs(rawArgs).map((a) => lowerObjectArrayDateBuiltinCalls(a, imports).trim());
-                    out +=
-                        args.length === 0
-                            ? '""'
-                            : args.length === 1
-                                ? `chr(${args[0]})`
-                                : `''.join(chr(__c) for __c in [${args.join(', ')}])`;
-                }
-                else {
-                    const arg = lowerObjectArrayDateBuiltinCalls(rawArgs, imports).trim();
-                    if (method === 'Object.keys')
-                        out += `list(${arg}.keys())`;
-                    else if (method === 'Object.values')
-                        out += `list(${arg}.values())`;
-                    else if (method === 'Object.entries')
-                        out += `list(${arg}.items())`;
-                    else
-                        out += `isinstance(${arg}, list)`;
-                }
-                i = closeIdx + 1;
-                continue;
-            }
-        }
-        if (expr.startsWith('Date.now()', i) && !(expr[i - 1] && /[\w.]/.test(expr[i - 1]))) {
-            imports?.add('from datetime import datetime, timezone');
-            out += 'int(datetime.now(timezone.utc).timestamp() * 1000)';
-            i += 'Date.now()'.length;
-            continue;
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Build the Python comprehension for one `Array.from(...)` call's argument list,
-// or return null if the call isn't a lowerable length-form. Uses the balanced
-// helpers (not regex) so a length value or arrow params containing braces/parens
-// don't desync (codex/gemini review of cd7c40ae).
-function tryLowerArrayFrom(args) {
-    if (args.length < 2)
-        return null;
-    // arg0 must be an object literal whose `length` property gives the count.
-    const arg0 = args[0].trim();
-    if (!arg0.startsWith('{') || matchBalancedParen(arg0, 0) !== arg0.length - 1)
-        return null;
-    let count = null;
-    for (const prop of splitTopLevelArgs(arg0.slice(1, -1))) {
-        const mm = prop.match(/^(?:length|["']length["'])\s*:\s*([\s\S]+)$/);
-        if (mm) {
-            count = mm[1].trim();
-            break;
-        }
-    }
-    if (count === null)
-        return null;
-    // arg1 must be an arrow `(params) => body` or `param => body`.
-    const arrowStr = args[1].trim();
-    let params;
-    let body;
-    if (arrowStr.startsWith('(')) {
-        const pClose = matchBalancedParen(arrowStr, 0);
-        if (pClose === -1)
-            return null;
-        const after = arrowStr.slice(pClose + 1).trim();
-        if (!after.startsWith('=>'))
-            return null;
-        params = splitTopLevelArgs(arrowStr.slice(1, pClose))
-            .map((s) => s.trim())
-            .filter(Boolean);
-        body = after.slice(2).trim();
-    }
-    else {
-        const am = arrowStr.match(/^([A-Za-z_$][\w$]*)\s*=>\s*([\s\S]+)$/);
-        if (!am)
-            return null;
-        params = [am[1]];
-        body = am[2].trim();
-    }
-    // Loop var = the INDEX (2nd param). The 1st param is the element, which is
-    // undefined for the length form, so it is NOT promoted to the loop variable
-    // (doing so would diverge from JS — `(x) => x` is [undefined…], not [0,1,…]).
-    // A non-simple index (destructuring) isn't a valid Python loop target → bail.
-    const idxVar = params[1] || '_';
-    if (!/^[A-Za-z_$][\w$]*$/.test(idxVar))
-        return null;
-    // `(_, i) => ({...})` parenthesizes the object body to disambiguate it from a
-    // block; unwrap ONLY when the enclosed body is an object literal, so a comma
-    // operator `(1, 2)` or grouped expr isn't mis-stripped (codex review).
-    if (body.startsWith('(') && matchBalancedParen(body, 0) === body.length - 1) {
-        const inner = body.slice(1, -1).trim();
-        if (inner.startsWith('{'))
-            body = inner;
-    }
-    // Recurse so a nested Array.from in the count or body is lowered too.
-    return `[${lowerArrayFromCalls(body)} for ${idxVar} in range(${lowerArrayFromCalls(count)})]`;
-}
-// Expand JS object-literal shorthand properties to explicit `key: key` so the
-// dict-key quoting pass can quote them: `{ items, page }` → `{ items: items,
-// page: page }`. Bracket/string-aware: only an object-literal entry that is a
-// bare identifier is expanded; `key: value`, `**spread`, computed keys, and
-// array/comprehension contents (`[]`) are left alone, and nested objects are
-// handled by recursing into each entry. Runs just before key quoting.
-function expandObjectShorthand(expr) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        if (c === '{') {
-            const close = matchBalancedParen(expr, i);
-            if (close !== -1) {
-                const rebuilt = splitTopLevelArgs(expr.slice(i + 1, close)).map((entry) => {
-                    const t = entry.trim();
-                    if (t === '')
-                        return entry;
-                    if (/^[A-Za-z_$][\w$]*$/.test(t))
-                        return `${t}: ${t}`;
-                    return expandObjectShorthand(entry);
-                });
-                out += `{${rebuilt.join(', ')}}`;
-                i = close + 1;
-                continue;
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-// Lower `Array.from({ length: N }, (_, i) => BODY)` to a Python list
-// comprehension `[BODY for i in range(N)]` (Express keeps Array.from — valid
-// JS). Balanced, string-aware scan; runs BEFORE the ref/key/template passes so
-// they lower N and BODY in place. Only the `{ length: N }` form is handled;
-// `Array.from(iterable, fn)` (map form) is left untouched. A call immediately
-// followed by a method chain (`.map`, `.filter`, …) is left raw rather than
-// lowered, because the array-method pass cannot consume a comprehension
-// receiver and would emit malformed Python (codex review of cd7c40ae).
-function lowerArrayFromCalls(expr) {
-    let out = '';
-    let i = 0;
-    let quote = null;
-    while (i < expr.length) {
-        const c = expr[i];
-        if (quote) {
-            out += c;
-            if (c === '\\') {
-                out += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            out += c;
-            i += 1;
-            continue;
-        }
-        const m = expr.slice(i).match(/^Array\.from\(/);
-        const prev = expr[i - 1];
-        if (m && !(prev && /[\w.]/.test(prev))) {
-            const openIdx = i + m[0].length - 1;
-            const closeIdx = matchBalancedParen(expr, openIdx);
-            if (closeIdx !== -1 && expr[closeIdx + 1] !== '.') {
-                const lowered = tryLowerArrayFrom(splitTopLevelArgs(expr.slice(openIdx + 1, closeIdx)));
-                if (lowered !== null) {
-                    out += lowered;
-                    i = closeIdx + 1;
-                    continue;
-                }
-            }
-        }
-        out += c;
-        i += 1;
-    }
-    return out;
-}
-function scanQuotedString(expr, startIndex, quote) {
-    for (let i = startIndex + 1; i < expr.length; i++) {
-        if (expr[i] === '\\') {
-            i += 1;
-            continue;
-        }
-        if (expr[i] === quote)
-            return i;
-    }
-    return -1;
-}
-function scanTemplateInterpolationEnd(expr, startIndex) {
-    let depth = 1;
-    for (let i = startIndex; i < expr.length; i++) {
-        const c = expr[i];
-        if (c === '"' || c === "'") {
-            const quotedEnd = scanQuotedString(expr, i, c);
-            if (quotedEnd === -1)
-                return -1;
-            i = quotedEnd;
-            continue;
-        }
-        if (c === '`') {
-            const templateEnd = scanTemplateLiteralEnd(expr, i);
-            if (templateEnd === -1)
-                return -1;
-            i = templateEnd;
-            continue;
-        }
-        if (c === '{')
-            depth += 1;
-        else if (c === '}') {
-            depth -= 1;
-            if (depth === 0)
-                return i;
-        }
-    }
-    return -1;
-}
-function scanTemplateLiteralEnd(expr, startIndex) {
-    for (let i = startIndex + 1; i < expr.length; i++) {
-        const c = expr[i];
-        if (c === '\\') {
-            i += 1;
-            continue;
-        }
-        if (c === '`')
-            return i;
-        if (c === '$' && expr[i + 1] === '{') {
-            const interpolationEnd = scanTemplateInterpolationEnd(expr, i + 2);
-            if (interpolationEnd === -1)
-                return -1;
-            i = interpolationEnd;
-        }
-    }
-    return -1;
-}
-function parseTemplateLiteral(expr, startIndex) {
-    const textParts = [];
-    const interpolationParts = [];
-    let text = '';
-    for (let i = startIndex + 1; i < expr.length;) {
-        const c = expr[i];
-        if (c === '\\') {
-            text += c;
-            if (i + 1 < expr.length)
-                text += expr[i + 1];
-            i += 2;
-            continue;
-        }
-        if (c === '`') {
-            textParts.push(text);
-            return { endIndex: i, textParts, interpolationParts };
-        }
-        if (c === '$' && expr[i + 1] === '{') {
-            textParts.push(text);
-            text = '';
-            const interpolationEnd = scanTemplateInterpolationEnd(expr, i + 2);
-            if (interpolationEnd === -1)
-                return undefined;
-            interpolationParts.push(expr.slice(i + 2, interpolationEnd));
-            i = interpolationEnd + 1;
-            continue;
-        }
-        text += c;
-        i += 1;
-    }
-    return undefined;
-}
-// Re-encode JS-template literal text (kept raw by parseTemplateLiteral, with `\x`
-// as two characters) for a Python double-quoted string. Most JS escapes are
-// ALSO valid Python escapes (`\n \t \r \b \f \v \\ \" \uXXXX \xXX \0`), so they
-// are preserved verbatim — decoding then re-encoding them only risks corrupting
-// the exotic ones (Codex reviews on 678e6bc1 and the escape-decoder commit).
-// Only the JS-specific escapes that Python does not recognise are converted to
-// the bare character: `\`` → backtick, `\$` → `$`, `\'` → `'`. A bare `"` (or a
-// bare trailing backslash, or raw control char) is escaped so the literal stays
-// valid.
-function escapeJsTemplateTextForPy(raw) {
-    let out = '';
-    for (let i = 0; i < raw.length; i++) {
-        const c = raw[i];
-        if (c === '\\' && i + 1 < raw.length) {
-            const next = raw[i + 1];
-            if (next === '`' || next === '$' || next === "'") {
-                out += next; // JS-only escape → bare char (Python has no such escape)
-            }
-            else {
-                out += `\\${next}`; // valid Python escape (\n, \uXXXX, \0, ...) — keep
-            }
-            i += 1;
-            continue;
-        }
-        if (c === '\\')
-            out += '\\\\'; // lone trailing backslash
-        else if (c === '"')
-            out += '\\"';
-        else if (c === '\n')
-            out += '\\n';
-        else if (c === '\r')
-            out += '\\r';
-        else if (c === '\t')
-            out += '\\t';
-        else
-            out += c;
-    }
-    return out;
-}
-function escapePythonTemplateText(text, forFormatTemplate) {
-    const escaped = escapeJsTemplateTextForPy(text);
-    if (!forFormatTemplate)
-        return escaped;
-    // str.format treats { } as field markers, so literal braces must be doubled.
-    return escaped.replace(/{/g, '{{').replace(/}/g, '}}');
-}
-function lowerTemplateLiteralToPython(parsed, pathParams, bodyFields, authUser, imports) {
-    if (parsed.interpolationParts.length === 0) {
-        return `"${escapePythonTemplateText(parsed.textParts.join(''), false)}"`;
-    }
-    const rewrittenInterpolations = parsed.interpolationParts.map((part) => rewriteFastAPIExpr(part.trim(), pathParams, bodyFields, authUser, imports));
-    let fmt = '';
-    for (let i = 0; i < parsed.textParts.length; i++) {
-        fmt += escapePythonTemplateText(parsed.textParts[i], true);
-        if (i < parsed.interpolationParts.length)
-            fmt += '{}';
-    }
-    return `"${fmt}".format(${rewrittenInterpolations.join(', ')})`;
-}
-function extractTemplateLiterals(expr, pathParams, bodyFields, authUser, imports) {
-    let maskedExpr = '';
-    const replacements = [];
-    let quote = null;
-    for (let i = 0; i < expr.length;) {
-        const c = expr[i];
-        if (quote) {
-            maskedExpr += c;
-            if (c === '\\') {
-                maskedExpr += expr[i + 1] ?? '';
-                i += 2;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            i += 1;
-            continue;
-        }
-        if (c === '"' || c === "'") {
-            quote = c;
-            maskedExpr += c;
-            i += 1;
-            continue;
-        }
-        if (c === '`') {
-            const parsed = parseTemplateLiteral(expr, i);
-            if (!parsed) {
-                maskedExpr += c;
-                i += 1;
-                continue;
-            }
-            const placeholder = `__KERN_TEMPLATE_${replacements.length}__`;
-            const lowered = lowerTemplateLiteralToPython(parsed, pathParams, bodyFields, authUser, imports);
-            replacements.push({ placeholder, lowered });
-            maskedExpr += placeholder;
-            i = parsed.endIndex + 1;
-            continue;
-        }
-        maskedExpr += c;
-        i += 1;
-    }
-    return { maskedExpr, replacements };
-}
-// Lower JS spread elements to Python unpacking, choosing the operator from the
-// enclosing bracket: `{...x}` → `{**x}`, `[...x]` / `f(...x)` → `[*x]` / `f(*x)`.
-// Bracket-aware (a stack) and string-aware (skips quoted contents) so a literal
-// "..." inside a string is left intact. Runs BEFORE the request-ref rewrites so
-// that, e.g., `...user.roles` becomes `*user.roles` and the auth rewrite's
-// `(?<!\.)` lookbehind no longer sees the spread's trailing dot.
-function lowerSpreadElements(expr) {
-    let out = '';
-    const stack = [];
-    let i = 0;
-    while (i < expr.length) {
-        const ch = expr[i];
-        if (ch === '"' || ch === "'") {
-            const q = ch;
-            out += ch;
-            i++;
-            while (i < expr.length) {
-                out += expr[i];
-                if (expr[i] === '\\') {
-                    i++;
-                    if (i < expr.length)
-                        out += expr[i];
-                    i++;
-                    continue;
-                }
-                if (expr[i] === q) {
-                    i++;
-                    break;
-                }
-                i++;
-            }
-            continue;
-        }
-        if (ch === '{' || ch === '[' || ch === '(') {
-            stack.push(ch);
-            out += ch;
-            i++;
-            continue;
-        }
-        if (ch === '}' || ch === ']' || ch === ')') {
-            stack.pop();
-            out += ch;
-            i++;
-            continue;
-        }
-        if (ch === '.' && expr[i + 1] === '.' && expr[i + 2] === '.') {
-            out += stack[stack.length - 1] === '{' ? '**' : '*';
-            i += 3;
-            // Collapse whitespace after the operator so `{ ... body }` yields tight
-            // `{**body}` — the model_dump pass matches `**body`, not `** body` (Codex).
-            while (i < expr.length && /\s/.test(expr[i]))
-                i++;
-            continue;
-        }
-        out += ch;
-        i++;
-    }
-    return out;
-}
-// ── Portable JS operators whose Python spelling diverges or doesn't exist ────
-// `%` (JS follows the DIVIDEND sign; Python's follows the divisor), `>>>` (no
-// Python equivalent — emit a 32-bit-masked unsigned shift), and `??` (null-only
-// coalesce, NOT falsy). Operand boundaries are found by a balanced, sign-aware
-// scan over precedence "stop" chars; findNextJsOperator skips string literals.
-function isUnarySign(expr, index) {
-    const c = expr[index];
-    if (c !== '+' && c !== '-')
-        return false;
-    let j = index - 1;
-    while (j >= 0 && /\s/.test(expr[j]))
-        j--;
-    return j < 0 || /[({[,:?+\-*/%<>=!&|^~]/.test(expr[j]);
-}
-function findLeftOperandStart(expr, opIndex, stopChars) {
-    let j = opIndex - 1;
-    while (j >= 0 && /\s/.test(expr[j]))
-        j--;
-    let depth = 0;
-    for (; j >= 0; j--) {
-        const c = expr[j];
-        if (c === '"' || c === "'" || c === '`') {
-            // A string operand is one atom — skip back to its opening quote (escape-
-            // aware) so a stop char inside the literal isn't mistaken for a boundary.
-            const q = c;
-            let k = j - 1;
-            while (k >= 0) {
-                if (expr[k] === q) {
-                    let b = 0;
-                    let p = k - 1;
-                    while (p >= 0 && expr[p] === '\\') {
-                        b++;
-                        p--;
-                    }
-                    if (b % 2 === 0)
-                        break;
-                }
-                k--;
-            }
-            j = k; // loop's j-- moves past the opening quote next
-            continue;
-        }
-        if (c === ')' || c === ']' || c === '}') {
-            depth++;
-            continue;
-        }
-        if (c === '(' || c === '[' || c === '{') {
-            if (depth === 0)
-                return j + 1;
-            depth--;
-            continue;
-        }
-        if (depth === 0 && stopChars.includes(c) && !isUnarySign(expr, j))
-            return j + 1;
-    }
-    return 0;
-}
-function findRightOperandEnd(expr, startIndex, stopChars) {
-    let j = startIndex;
-    while (j < expr.length && /\s/.test(expr[j]))
-        j++;
-    let depth = 0;
-    let quote = null;
-    for (; j < expr.length; j++) {
-        const c = expr[j];
-        if (quote) {
-            if (c === '\\') {
-                j++;
-                continue;
-            }
-            if (c === quote)
-                quote = null;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            continue;
-        }
-        if (c === '(' || c === '[' || c === '{') {
-            depth++;
-            continue;
-        }
-        if (c === ')' || c === ']' || c === '}') {
-            if (depth === 0)
-                return j;
-            depth--;
-            continue;
-        }
-        if (depth === 0 && stopChars.includes(c) && !isUnarySign(expr, j))
-            return j;
-    }
-    return expr.length;
-}
-function findNextJsOperator(expr, op, from) {
-    let quote = null;
-    for (let i = 0; i < expr.length; i++) {
-        const c = expr[i];
-        if (quote) {
-            if (c === '\\')
-                i += 1;
-            else if (c === quote)
-                quote = null;
-            continue;
-        }
-        if (c === '"' || c === "'" || c === '`') {
-            quote = c;
-            continue;
-        }
-        if (i >= from && expr.startsWith(op, i))
-            return i;
-    }
-    return -1;
-}
-function replaceJsOperator(expr, op, stopChars, lower) {
-    let result = expr;
-    let from = 0;
-    while (true) {
-        const opIndex = findNextJsOperator(result, op, from);
-        if (opIndex === -1)
-            return result;
-        const leftStart = findLeftOperandStart(result, opIndex, stopChars);
-        const rightEnd = findRightOperandEnd(result, opIndex + op.length, stopChars);
-        const left = result.slice(leftStart, opIndex).trim();
-        const right = result.slice(opIndex + op.length, rightEnd).trim();
-        if (!left || !right) {
-            // Not a binary use here — skip past this occurrence to avoid a loop.
-            from = opIndex + op.length;
-            continue;
-        }
-        const lowered = lower(left, right);
-        result = `${result.slice(0, leftStart)}${lowered}${result.slice(rightEnd)}`;
-        from = leftStart + lowered.length;
-    }
-}
-function lowerPortableJsOperators(expr, imports) {
-    // `%` binds at multiplicative precedence; `>>>` and `??` are loose (low).
-    const multiplicativeStops = ',:?+-*/%<>=!&|^';
-    const looseBinaryStops = ',:?';
-    let result = expr;
-    // >>> first (longest operator); mask the dividend to 32 bits and the shift
-    // count to 5 bits, mirroring JS ToUint32 + (count & 31).
-    result = replaceJsOperator(result, '>>>', looseBinaryStops, (l, r) => `((${l} & 0xFFFFFFFF) >> (${r} & 31))`);
-    // `%`: math.fmod follows the DIVIDEND sign like JS (and keeps the fractional
-    // part for float operands — int() would wrongly truncate 5.5 % 2 → 1).
-    result = replaceJsOperator(result, '%', multiplicativeStops, (l, r) => {
-        imports?.add('import math as __k_math');
-        return `__k_math.fmod(${l}, ${r})`;
-    });
-    result = replaceJsOperator(result, '??', looseBinaryStops, (l, r) => `(${l} if ${l} is not None else ${r})`);
-    return result;
-}
-export function rewriteFastAPIExpr(expr, pathParams, bodyFields = new Set(), authUser = false, imports, hoistedDefs, closureSeq) {
-    try {
-        const tokens = tokenizeJSExpr(expr);
-        const comparisonProbe = expr.replace(/>>>|>>|<</g, '');
-        const hasLooseComparison = /(?:===|!==|==|!=|<=|>=|<|>)/.test(comparisonProbe);
-        const hasBitwiseOrModulo = !expr.includes('=>') && !hasLooseComparison && tokens.some((t) => t.type === 'UNARY' || t.type === 'OP');
-        if (hasBitwiseOrModulo) {
-            const ast = parseTokens(tokens);
-            expr = codegenASTToPython(ast, imports);
-        }
-    }
-    catch (_err) {
-        // Graceful fallback to original expr string if parsing/emission fails
-    }
-    const { maskedExpr, replacements } = extractTemplateLiterals(expr, pathParams, bodyFields, authUser, imports);
-    let result = maskedExpr;
-    // Spread → unpacking first, so the request-ref rewrites below see clean
-    // operands (e.g. `*user.roles`, not `...user.roles`).
-    result = lowerSpreadElements(result);
-    // Expand object shorthand BEFORE Array.from lowering, so a shorthand length
-    // object `Array.from({ length }, …)` becomes `{ length: length }` and is
-    // recognised (codex review of d75a9d05). No later pass creates new object
-    // literals, so this single early pass covers length objects, arrow bodies,
-    // and every other object.
-    result = expandObjectShorthand(result);
-    // Array.from(length, arrow) → list comprehension. Runs before the ref/key
-    // passes so they lower the count and body of the produced comprehension.
-    result = lowerArrayFromCalls(result);
-    // params.X → X (function param) for path params
-    for (const param of pathParams) {
-        result = result.replace(new RegExp(`\\bparams\\.${param}\\b`, 'g'), param);
-    }
-    // Fallback: any remaining params.X → X (for query params not in pathParams)
-    result = result.replace(/\bparams\.([A-Za-z_]\w*)/g, '$1');
-    // user.X → user["X"]: with auth, `user` is the decoded JWT payload (a dict
-    // returned by auth_required/auth_optional), so attribute access would raise
-    // AttributeError. Only applied when the route declares auth (Codex review).
-    // Skip text inside string literals so `{{"user.id"}}` isn't corrupted to
-    // `"user["id"]"` (Codex review on 02ecb2fa), and require `user` NOT be a
-    // property of something else (negative lookbehind `(?<!\.)`) so a nested
-    // body access like `body.user.id` is left intact (Kimi review on 02ecb2fa).
-    if (authUser) {
-        const USER_FIELD_RE = new RegExp(`${STRING_LITERAL_ALT}|(?<!\\.)\\buser\\.([A-Za-z_]\\w*)`, 'g');
-        result = result.replace(USER_FIELD_RE, (match, field) => (field ? `user["${field}"]` : match));
-    }
-    // body.X → body.<snake_case(X)>: the generated Pydantic model snake-cases
-    // every field, so a camelCase access would raise AttributeError at runtime.
-    // Only remap fields the model actually declares; leave unknown `body.X`
-    // (e.g. external validate schemas) untouched.
-    result = result.replace(/\bbody\.([A-Za-z_]\w*)/g, (match, field) => bodyFields.has(field) ? `body.${toSnakeCase(field)}` : match);
-    // Spreading the whole request body: `{**body}` raises TypeError because a
-    // Pydantic model is not a mapping, so unpack its dict form instead. This is
-    // unconditional: whenever the `body` symbol exists it is a Pydantic model
-    // (inline `RequestBody`, or an external `validate` schema typed `body: X` for
-    // POST/PUT/PATCH) — there is no `body: dict` codegen path, so model_dump() is
-    // always correct. Keying on bodyFields would wrongly skip external schemas
-    // (their field names are unknown but the param is still a model). A
-    // `**body.field` member spread is left alone via the `(?!\s*\.)` guard.
-    result = result.replace(/\*\*body\b(?!\s*\.)/g, '**body.model_dump()');
-    // query.X → X (function param)
-    result = result.replace(/\bquery\.([A-Za-z_]\w*)/g, '$1');
-    // headers.X → request.headers.get("X")
-    result = result.replace(/\bheaders\.([A-Za-z_][\w-]*)/g, (_m, key) => `request.headers.get("${key}")`);
-    // effectName.result → effect_name (effect variables hold the result directly, snake_cased)
-    result = result.replace(/\b([A-Za-z_]\w*)\.result\b/g, (_m, name) => toSnakeCase(name));
-    // ── JS-to-Python expression lowerings ─────────────────────────────────
-    // Array methods first (so any `===` inside an arrow body is hoisted into
-    // a list-comprehension predicate that the strict-equality pass below
-    // then catches).
-    result = lowerJsArrayMethods(result, { pathParams, bodyFields, authUser, imports, hoistedDefs, closureSeq });
-    // Strict equality: skip text inside quoted strings so a user message
-    // like `"use === for strict equality"` doesn't get mangled to `==`.
-    result = result.replace(STRICT_EQ_RE, (match) => {
-        if (match === '===')
-            return '==';
-        if (match === '!==')
-            return '!=';
-        return match; // quoted string — return unchanged
-    });
-    // JS literals → Python equivalents. Same string-skip trick — a message
-    // like `"undefined behavior"` must not be rewritten to `"None behavior"`.
-    result = result.replace(JS_LITERAL_RE, (match) => {
-        if (match === 'undefined' || match === 'null')
-            return 'None';
-        if (match === 'true')
-            return 'True';
-        if (match === 'false')
-            return 'False';
-        return match; // quoted string
-    });
-    // ── Host-builtin lowering (JS globals → Python stdlib) ────────────────
-    // crypto / Date are fixed forms matched by regex with a `(?<![\w.])` guard so
-    // a custom receiver (`some.crypto.randomUUID()`) is left untouched. The JSON
-    // calls need balanced argument parsing (regex can't), so they go through the
-    // string-aware scanner `lowerJsonBuiltinCalls`.
-    // crypto.randomUUID() → str(uuid.uuid4())
-    result = result.replace(new RegExp(`${STRING_LITERAL_ALT}|(?<![\\w.])crypto\\.randomUUID\\(\\)`, 'g'), (match) => {
-        if (match === 'crypto.randomUUID()') {
-            imports?.add('import uuid');
-            return 'str(uuid.uuid4())';
-        }
-        return match; // string literal — leave untouched
-    });
-    // new Date().toISOString() → datetime.now(timezone.utc).isoformat()
-    result = result.replace(new RegExp(`${STRING_LITERAL_ALT}|(?<![\\w.])new Date\\(\\)\\.toISOString\\(\\)`, 'g'), (match) => {
-        if (match === 'new Date().toISOString()') {
-            imports?.add('from datetime import datetime, timezone');
-            return 'datetime.now(timezone.utc).isoformat()';
-        }
-        return match;
-    });
-    // Portable operators whose Python spelling diverges (`%`, `??`) or is absent
-    // (`>>>`) — lower before the number builtins emit any `%`-format strings.
-    result = lowerPortableJsOperators(result, imports);
-    // JSON.stringify(...) → json.dumps(...) / JSON.parse(...) → json.loads(...)
-    result = lowerJsonBuiltinCalls(result, imports);
-    // Number/Math arithmetic builtins in portable expressions.
-    result = lowerMathBuiltinCalls(result, imports);
-    // Number parsing and formatting builtins.
-    result = lowerNumberBuiltinCalls(result, imports);
-    // String builtins in portable expressions (bare renames + pad → rjust/ljust).
-    result = lowerStringBuiltinCalls(result);
-    // Argument-taking string methods: replace (first-only), substring → slice,
-    // repeat → `*`, and the split(sep, limit) maxsplit trap.
-    result = lowerStringArgMethods(result);
-    // Object/Array/Date host builtins in portable expressions.
-    result = lowerObjectArrayDateBuiltinCalls(result, imports);
-    // Object-literal keys → quoted Python dict keys (`{userId: x}` →
-    // `{"userId": x}`). Applied last, mirroring the raw `res.json(...)` path's
-    // outer quote-after-lower order; runs after array-method lowering so dicts
-    // produced inside list comprehensions are quoted too.
-    result = quoteObjectKeysOutsideStrings(result);
-    for (const replacement of replacements) {
-        result = result.split(replacement.placeholder).join(replacement.lowered);
-    }
-    result = result.split(LAMBDA_COLON_PLACEHOLDER).join(':');
-    return result;
-}
-export function extractExprCode(prop) {
-    if (typeof prop === 'object' && prop !== null && prop.__expr)
-        return prop.code;
-    return typeof prop === 'string' ? prop : '';
-}
 export function addRespondImports(respondNode, imports) {
     const rp = getProps(respondNode);
     if (rp.redirect)
@@ -2021,250 +52,4 @@ export function addRespondImports(respondNode, imports) {
     if (rp.error)
         imports.add('from fastapi import HTTPException');
 }
-function tokenizeJSExpr(expr) {
-    const tokens = [];
-    let i = 0;
-    while (i < expr.length) {
-        while (i < expr.length && /\s/.test(expr[i])) {
-            i++;
-        }
-        if (i >= expr.length)
-            break;
-        const char = expr[i];
-        if (char === '(') {
-            tokens.push({ type: 'LP' });
-            i++;
-            continue;
-        }
-        if (char === ')') {
-            tokens.push({ type: 'RP' });
-            i++;
-            continue;
-        }
-        if (char === '~') {
-            tokens.push({ type: 'UNARY', value: '~' });
-            i++;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            const quote = char;
-            let val = quote;
-            i++;
-            while (i < expr.length) {
-                const c = expr[i];
-                val += c;
-                if (c === '\\') {
-                    val += expr[i + 1] ?? '';
-                    i += 2;
-                    continue;
-                }
-                if (c === quote) {
-                    i++;
-                    break;
-                }
-                i++;
-            }
-            tokens.push({ type: 'TEXT', value: val });
-            continue;
-        }
-        if (char === '&') {
-            if (expr[i + 1] === '&') {
-                // Fall through to TEXT
-            }
-            else {
-                tokens.push({ type: 'OP', value: '&' });
-                i++;
-                continue;
-            }
-        }
-        if (char === '|') {
-            if (expr[i + 1] === '|') {
-                // Fall through to TEXT
-            }
-            else {
-                tokens.push({ type: 'OP', value: '|' });
-                i++;
-                continue;
-            }
-        }
-        if (char === '^' || char === '%') {
-            tokens.push({ type: 'OP', value: char });
-            i++;
-            continue;
-        }
-        if (char === '<' && expr[i + 1] === '<') {
-            tokens.push({ type: 'OP', value: '<<' });
-            i += 2;
-            continue;
-        }
-        // `>>>` (unsigned right shift) is intentionally OUT of the int32 AST path
-        // (deferred — see the numbermodel oracle note). Bail the whole expr out of
-        // the AST path by throwing (caught in rewriteFastAPIExpr) so the downstream
-        // string-level operator lowering — which 32-bit-masks `>>>` correctly —
-        // handles it. Must be checked BEFORE `>>`, else `>>` greedily eats two of
-        // the three `>` and leaves a stray `>` that mangles the operand.
-        if (char === '>' && expr[i + 1] === '>' && expr[i + 2] === '>') {
-            throw new Error('unsupported-operator: >>> (defer to string lowering)');
-        }
-        if (char === '>' && expr[i + 1] === '>') {
-            tokens.push({ type: 'OP', value: '>>' });
-            i += 2;
-            continue;
-        }
-        let text = '';
-        while (i < expr.length) {
-            const c = expr[i];
-            if (c === '(' || c === ')' || c === '~' || c === '^' || c === '%') {
-                break;
-            }
-            if (c === '"' || c === "'" || c === '`') {
-                break;
-            }
-            if (c === '&') {
-                if (expr[i + 1] === '&') {
-                    text += '&&';
-                    i += 2;
-                    continue;
-                }
-                else {
-                    break;
-                }
-            }
-            if (c === '|') {
-                if (expr[i + 1] === '|') {
-                    text += '||';
-                    i += 2;
-                    continue;
-                }
-                else {
-                    break;
-                }
-            }
-            if (c === '<' && expr[i + 1] === '<') {
-                break;
-            }
-            if (c === '>' && expr[i + 1] === '>') {
-                break;
-            }
-            text += c;
-            i++;
-        }
-        if (text) {
-            tokens.push({ type: 'TEXT', value: text.trimEnd() });
-        }
-    }
-    return tokens;
-}
-function parseTokens(tokens) {
-    let index = 0;
-    function peek() {
-        return tokens[index];
-    }
-    function consume() {
-        return tokens[index++];
-    }
-    function getPrecedence(op) {
-        switch (op) {
-            case '|':
-                return 1;
-            case '^':
-                return 2;
-            case '&':
-                return 3;
-            case '<<':
-            case '>>':
-                return 4;
-            case '%':
-                return 5;
-            default:
-                return 0;
-        }
-    }
-    function parseExpression(precedence) {
-        let left = parsePrimary();
-        while (true) {
-            const next = peek();
-            if (!next || next.type !== 'OP')
-                break;
-            const opPrecedence = getPrecedence(next.value);
-            if (opPrecedence < precedence)
-                break;
-            consume();
-            const right = parseExpression(opPrecedence + 1);
-            left = { type: 'binary', op: next.value, left, right };
-        }
-        return left;
-    }
-    function parsePrimary() {
-        const t = peek();
-        if (!t)
-            throw new Error('Unexpected EOF');
-        if (t.type === 'UNARY') {
-            consume();
-            const arg = parseExpression(6);
-            return { type: 'unary', op: t.value, arg };
-        }
-        if (t.type === 'LP') {
-            consume();
-            const inner = parseExpression(0);
-            const next = peek();
-            if (next && next.type === 'RP') {
-                consume();
-            }
-            return { type: 'group', arg: inner };
-        }
-        if (t.type === 'TEXT') {
-            consume();
-            return { type: 'text', value: t.value };
-        }
-        consume();
-        return { type: 'text', value: t.type === 'OP' ? t.value : '' };
-    }
-    return parseExpression(0);
-}
-function codegenASTToPython(node, imports) {
-    switch (node.type) {
-        case 'text':
-            return node.value;
-        case 'group':
-            return `(${codegenASTToPython(node.arg, imports)})`;
-        case 'unary': {
-            const argStr = codegenASTToPython(node.arg, imports);
-            if (node.op === '~') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(~_i32(${argStr}))`;
-            }
-            return `${node.op}${argStr}`;
-        }
-        case 'binary': {
-            const leftStr = codegenASTToPython(node.left, imports);
-            const rightStr = codegenASTToPython(node.right, imports);
-            if (node.op === '|') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(_i32(${leftStr}) | _i32(${rightStr}))`;
-            }
-            if (node.op === '&') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(_i32(${leftStr}) & _i32(${rightStr}))`;
-            }
-            if (node.op === '^') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(_i32(${leftStr}) ^ _i32(${rightStr}))`;
-            }
-            if (node.op === '<<') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(_i32(${leftStr}) << (_i32(${rightStr}) & 31))`;
-            }
-            if (node.op === '>>') {
-                imports?.add(KERN_I32_HELPER_PY);
-                return `_i32(_i32(${leftStr}) >> (_i32(${rightStr}) & 31))`;
-            }
-            if (node.op === '%') {
-                imports?.add(KERN_TMOD_HELPER_PY);
-                return `_tmod(${leftStr}, ${rightStr})`;
-            }
-            return `${leftStr} ${node.op} ${rightStr}`;
-        }
-    }
-}
 //# sourceMappingURL=fastapi-response.js.map