depyo 1.0.3 → 1.2.0

package/lib/PycReader.js

@@ -38,13 +38,14 @@ const TypeSmallTuple = ')';
 const TypeShortAscii = 'z';
 const TypeShortAsciiInterned = 'Z';
 const TypeObjectReference = 'r';
+const TypeSlice = ':'; // CPython 3.14+: marshal'd slice constant (start, stop, step)
 const KnownTypes = new Set([
     TypeNull, TypeNone, TypeFalse, TypeTrue, TypeStopiter, TypeEllipsis,
     TypeInt, TypeInt64, TypeFloat, TypeBinaryFloat, TypeComplex, TypeBinaryComplex,
     TypeLong, TypeString, TypeInterned, TypeStringRef, TypeTuple, TypeList,
     TypeDict, TypeCode, TypeCode2, TypeUnicode, TypeUnknown, TypeSet, TypeFrozenset,
     TypeAscii, TypeAsciiInterned, TypeSmallTuple, TypeShortAscii, TypeShortAsciiInterned,
-    TypeObjectReference
+    TypeObjectReference, TypeSlice
 ]);
 
 const MagicToVersion = {
@@ -590,6 +591,14 @@ class PycReader
                     obj.ClassName = "Py_FrozenSet";
                     obj.Value = frozenSet;
                     break;
+                case TypeSlice: {
+                    const sliceStart = this.ReadObject();
+                    const sliceStop = this.ReadObject();
+                    const sliceStep = this.ReadObject();
+                    obj.ClassName = "Py_Slice";
+                    obj.Value = { start: sliceStart, stop: sliceStop, step: sliceStep };
+                    break;
+                }
                 case TypeCode:
                 case TypeCode2:
                     let codeObj = this.ReadCodeObject();

package/lib/PythonObject.js

@@ -57,7 +57,9 @@ class PythonObject {
                 .replace(/\\/g, '\\\\')
                 .replace(/\n/g, '\\n')
                 .replace(/\r/g, '\\r')
-                .replace(/\t/g, '\\t');
+                .replace(/\t/g, '\\t')
+                .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, c =>
+                    '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'));
             let quote = '"';
             if (escaped.includes('"')) {
                 if (!escaped.includes("'")) {
@@ -192,7 +194,13 @@ class PythonObject {
 
             case "Py_Complex":
                 return `${this.Value[0]}+${this.Value[1]}j`;
-    
+
+            case "Py_Slice": {
+                const part = (v) => v instanceof PythonObject ? v.toReprString() : String(v);
+                const { start, stop, step } = this.Value || {};
+                return `slice(${part(start)}, ${part(stop)}, ${part(step)})`;
+            }
+
             default:
                 return ["Py_String"].includes(this.ClassName) ? this.Value.toString("ascii") : null;
         }

package/lib/ast/ast_node.js

@@ -212,9 +212,14 @@ class ASTNodeList extends ASTNode {
         if (this.emptyBlock()) {
             result.add("pass");
         } else {
+            // Defensive: a handler may have appended an undefined slot (e.g.
+            // a stack-pop that returned undefined on a malformed pyc).
+            // Without this, the sibling-link loop crashes on `undefined.prevSibling`
+            // and aborts rendering of the whole code object.
+            const list = this.list.filter(n => n);
             let prevNode = null;
 
-            for (let node of this.list) {
+            for (let node of list) {
                 if (prevNode) {
                     prevNode.nextSibling = node;
                 }
@@ -223,7 +228,7 @@ class ASTNodeList extends ASTNode {
             }
             prevNode = null;
 
-            for (let node of this.list) {
+            for (let node of list) {
                 if (node.skip) {
                     continue;
                 }
@@ -258,7 +263,19 @@ class ASTNodeList extends ASTNode {
                     }
                 }
     
-                if (prevNode && spacing == 0 && sourceFragment.length == 1) {
+                // Only join with `; ` between two simple (non-compound) statements
+                // that also happen to be on the same source line. A compound block
+                // (if/while/for/try/function/class) must never be semicolon-joined
+                // to a following sibling — doing so swallows the sibling into the
+                // block's body and breaks structure.
+                const prevIsCompound = prevNode instanceof ASTBlock ||
+                                       prevNode instanceof ASTFunction ||
+                                       prevNode instanceof ASTClass;
+                const nodeIsCompound = node instanceof ASTBlock ||
+                                       node instanceof ASTFunction ||
+                                       node instanceof ASTClass;
+                if (prevNode && spacing == 0 && sourceFragment.length == 1 &&
+                    !prevIsCompound && !nodeIsCompound) {
                     result.lastLineAppend((prevNode ? "; " : "") + sourceFragment.toString(), false);
                 } else {
                     const blankCount = rawSpacing ? Math.max(0, spacing - 1) : (spacing > 1 ? 1 : 0);
@@ -465,7 +482,11 @@ class ASTObject extends ASTNode {
                 .replace(/\\/g, '\\\\')
                 .replace(/\n/g, '\\n')
                 .replace(/\r/g, '\\r')
-                .replace(/\t/g, '\\t');
+                .replace(/\t/g, '\\t')
+                // Any remaining C0/DEL byte must be hex-escaped; leaving a raw
+                // NUL or BEL in the source makes the output unparseable.
+                .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, c =>
+                    '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'));
             let quote = '"';
             if (escaped.includes('"')) {
                 if (!escaped.includes("'")) {
@@ -1103,7 +1124,13 @@ class ASTStore extends ASTNode {
             if (inLambda) {
                 result.lastLineAppend(methodBody);
             } else {
-                result.add(methodBody);
+                const bodyHasContent = methodBody && methodBody.toString().trim().length;
+                const hasGlobals = codeObject.Globals && codeObject.Globals.size > 0;
+                if (bodyHasContent) {
+                    result.add(methodBody);
+                } else if (!hasGlobals) {
+                    result.add("pass");
+                }
             }
             result.decreaseIndent();
 
@@ -2539,19 +2566,33 @@ class ASTBlock extends ASTNode {
                     result.add("pass");
                 }
             } else {
+                // Emit body nodes first, then trailing dedented handlers. If
+                // every body node was `skip`-ed (e.g. Try body whose sole
+                // child was consumed by ternary collapse), the block would
+                // print `try:` with no body — inject a `pass` placeholder so
+                // the resulting source stays parseable.
+                let emittedBodyNode = false;
+                const handlerTail = [];
                 renderNodes.map(node => {
                     if (!node || node.skip) {
                         return;
                     }
                     const isHandler = node.blockType == ASTBlock.BlockType.Except || node.blockType == ASTBlock.BlockType.Finally;
                     if (isHandler) {
-                        result.decreaseIndent();
-                        result.add(node.codeFragment());
-                        result.increaseIndent();
+                        handlerTail.push(node);
                     } else {
                         result.add(node.codeFragment());
+                        emittedBodyNode = true;
                     }
                 });
+                if (!emittedBodyNode) {
+                    result.add("pass");
+                }
+                for (const h of handlerTail) {
+                    result.decreaseIndent();
+                    result.add(h.codeFragment());
+                    result.increaseIndent();
+                }
             }
         } else {
             result.add("pass");
@@ -2566,6 +2607,17 @@ class ASTBlock extends ASTNode {
     }
 }
 
+// Predicate: can this node legally appear as one branch of a ternary `x if c else y`?
+// Block-shaped nodes render multi-line and an ASTKeyword (pass/break/continue) is a
+// statement, not an expression — appending " if c else y" to either is invalid Python.
+function isTernaryExprNode(node) {
+    if (node == null) return false;
+    if (node instanceof ASTBlock) return false;
+    if (node instanceof ASTKeyword) return false;
+    if (node instanceof ASTReturn) return false;
+    return true;
+}
+
 class ASTCondBlock extends ASTBlock {
     static InitCondition = {
         Uninited: 0,
@@ -2600,7 +2652,23 @@ class ASTCondBlock extends ASTBlock {
     
     codeFragment() {
         let result = new PycResult("", true);
+        // Cycle guard: if a control-flow handler accidentally nests a block
+        // inside its own descendants, the recursive render would blow the JS
+        // stack and abort the enclosing code object. Detect re-entry on the
+        // same instance, emit a sentinel, and let the rest of the file render.
+        if (this.__rendering) {
+            result.add("###CYCLE###");
+            return result;
+        }
+        this.__rendering = true;
+        try {
+            return this._codeFragmentImpl(result);
+        } finally {
+            this.__rendering = false;
+        }
+    }
 
+    _codeFragmentImpl(result) {
         // This is the assert case
         if (this.blockType == ASTBlock.BlockType.If && this.negative && this.condition && this.nodes.length == 1 && this.nodes[0] instanceof ASTRaise) {
             result.lastLineAppend("assert ", false);
@@ -2615,9 +2683,11 @@ class ASTCondBlock extends ASTBlock {
             this.prevSibling instanceof ASTStore &&
             this.blockType == ASTBlock.BlockType.If &&
             this.nodes.length == 1 &&
+            isTernaryExprNode(this.nodes[0]) &&
             this.nextSibling instanceof ASTCondBlock &&
             this.nextSibling?.type == ASTBlock.BlockType.Else &&
             this.nextSibling?.nodes.length == 1 &&
+            isTernaryExprNode(this.nextSibling.nodes[0]) &&
             this.condition.line >= 0 &&
             this.condition.line == this.nodes[0].line &&
             this.condition.line == this.nextSibling?.nodes[0].line
@@ -2634,7 +2704,10 @@ class ASTCondBlock extends ASTBlock {
             this.prevSibling == null &&
             this.blockType == ASTBlock.BlockType.If &&
             this.nodes.length == 1 &&
+            isTernaryExprNode(this.nodes[0]) &&
             this.nextSibling instanceof ASTReturn &&
+            this.nextSibling.value &&
+            isTernaryExprNode(this.nextSibling.value) &&
             this.condition.line == this.nodes[0].line &&
             this.condition.line == this.nextSibling?.value.line
         ) {
@@ -3137,12 +3210,27 @@ class ASTFormattedValue extends ASTNode {
         return this.m_format_spec;
     }
     
-    codeFragment() {
+    codeFragment(outerQuote = null) {
         // Format: {value} or {value!r} or {value:.2f}
+        // `outerQuote` is set only when this FormattedValue is being rendered
+        // inside an enclosing f-string; nested strings must then use the
+        // opposite delimiter so the outer string does not close prematurely.
+        const innerQuote = outerQuote === '"' ? "'" :
+                           outerQuote === "'" ? '"' : '"';
         let result = "{";
 
         if (this.m_val) {
-            result += this.m_val.codeFragment();
+            if (this.m_val instanceof ASTJoinedStr) {
+                // Only force a flipped quote when we actually have an outer
+                // f-string; otherwise let the nested string keep its default.
+                if (outerQuote) {
+                    result += this.m_val.codeFragment(innerQuote);
+                } else {
+                    result += this.m_val.codeFragment();
+                }
+            } else {
+                result += this.m_val.codeFragment();
+            }
         }
 
         // Add conversion flag (!s, !r, !a)
@@ -3163,7 +3251,10 @@ class ASTFormattedValue extends ASTNode {
             result += ":";
             // Format spec can be ASTJoinedStr (nested f-string) or string constant
             if (this.m_format_spec instanceof ASTJoinedStr) {
-                result += this.m_format_spec.codeFragment();
+                // Format-spec content is already inside the outer f-string's
+                // braces, so its literal parts must not use the outer quote.
+                const specQuote = outerQuote ? innerQuote : '"';
+                result += this.m_format_spec.codeFragment(specQuote, true);
             } else if (this.m_format_spec instanceof ASTObject) {
                 // String constant like ".2f"
                 result += this.m_format_spec.object.Value;
@@ -3196,9 +3287,14 @@ class ASTJoinedStr extends ASTNode {
     get lastLine() {
         return this.values[this.values.length - 1]?.lastLine;
     }
-    codeFragment() {
+    codeFragment(quoteChar = '"', bareInnerForFormatSpec = false) {
         // PEP 750 t-strings use t"..." prefix; otherwise f-string.
-        let result = (this.isTemplateString ? 't"' : 'f"');
+        // `quoteChar` lets nested f-strings pick the opposite delimiter so
+        // they don't collide with the enclosing string. `bareInnerForFormatSpec`
+        // skips the f"..." wrapper entirely (used when this ASTJoinedStr is a
+        // format spec nested inside {...}).
+        const prefix = this.isTemplateString ? 't' : 'f';
+        let result = bareInnerForFormatSpec ? "" : `${prefix}${quoteChar}`;
 
         // Values are in reverse order (BUILD_STRING pops from stack)
         // So we need to reverse them
@@ -3232,8 +3328,10 @@ class ASTJoinedStr extends ASTNode {
                         let prefix = prevStr.substring(0, prevStr.length - match[0].length);
 
                         // Remove the previously added literal and replace with prefix + {var=}
+                        let quoteEsc = quoteChar === '"' ? /"/g : /'/g;
+                        let quoteReplace = quoteChar === '"' ? '\\"' : "\\'";
                         let beforeLiteral = result.lastIndexOf(prevStr.replace(/\\/g, '\\\\')
-                            .replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\t/g, '\\t'));
+                            .replace(quoteEsc, quoteReplace).replace(/\n/g, '\\n').replace(/\t/g, '\\t'));
 
                         if (beforeLiteral !== -1) {
                             result = result.substring(0, beforeLiteral);
@@ -3242,7 +3340,7 @@ class ASTJoinedStr extends ASTNode {
                         // Add prefix (escaped) if present
                         if (prefix) {
                             let escapedPrefix = prefix.replace(/\\/g, '\\\\');
-                            escapedPrefix = escapedPrefix.replace(/"/g, '\\"');
+                            escapedPrefix = escapedPrefix.replace(quoteEsc, quoteReplace);
                             escapedPrefix = escapedPrefix.replace(/\n/g, '\\n');
                             escapedPrefix = escapedPrefix.replace(/\t/g, '\\t');
                             result += escapedPrefix;
@@ -3254,16 +3352,25 @@ class ASTJoinedStr extends ASTNode {
                     }
                 }
 
-                // {expression} part
-                result += value.codeFragment();
-            } else if (value instanceof ASTObject && value.object?.ClassName === 'Py_String') {
+                // {expression} part - pass our own quote char so nested
+                // f-strings / strings inside pick a compatible delimiter.
+                result += value.codeFragment(quoteChar);
+                // result above calls ASTFormattedValue.codeFragment(outerQuote).
+            } else if (value instanceof ASTObject && ['Py_String', 'Py_Unicode'].includes(value.object?.ClassName)) {
                 // Literal string part - need to escape special chars
                 let str = value.object.Value;
-                // Escape backslashes and quotes
+                // Escape backslashes and the current quote char
                 str = str.replace(/\\/g, '\\\\');
-                str = str.replace(/"/g, '\\"');
+                if (quoteChar === '"') {
+                    str = str.replace(/"/g, '\\"');
+                } else {
+                    str = str.replace(/'/g, "\\'");
+                }
                 str = str.replace(/\n/g, '\\n');
+                str = str.replace(/\r/g, '\\r');
                 str = str.replace(/\t/g, '\\t');
+                str = str.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, c =>
+                    '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'));
                 result += str;
             } else {
                 // Fallback for unexpected types
@@ -3271,7 +3378,9 @@ class ASTJoinedStr extends ASTNode {
             }
         }
 
-        result += '"';
+        if (!bareInnerForFormatSpec) {
+            result += quoteChar;
+        }
         return result;
     }
 

package/lib/bytecode/python_3_14.js

@@ -7,7 +7,7 @@ const opcodes = [
     [0, new OpCode(OpCodes.CACHE, "CACHE")],
     [1, new OpCode(OpCodes.BINARY_SLICE, "BINARY_SLICE")],
     [2, new OpCode(OpCodes.BUILD_TEMPLATE, "BUILD_TEMPLATE")],
-    [4, new OpCode(OpCodes.CALL_FUNCTION_EX, "CALL_FUNCTION_EX")],
+    [4, new OpCode(OpCodes.CALL_FUNCTION_EX_A, "CALL_FUNCTION_EX", {HasArgument: true})],
     [5, new OpCode(OpCodes.CHECK_EG_MATCH, "CHECK_EG_MATCH")],
     [6, new OpCode(OpCodes.CHECK_EXC_MATCH, "CHECK_EXC_MATCH")],
     [7, new OpCode(OpCodes.CLEANUP_THROW, "CLEANUP_THROW")],

package/lib/handlers/binary_ops.js

@@ -2,6 +2,15 @@ const AST = require('../ast/ast_node');
 
 function handleBinaryOpA()
 {
+    // Python 3.14 fused BINARY_SUBSCR into BINARY_OP arg=26 (NB_SUBSCR).
+    if (this.code.Current.Argument === 26) {
+        let subscr = this.dataStack.pop();
+        let src = this.dataStack.pop();
+        let node = new AST.ASTSubscr(src, subscr);
+        node.line = this.code.Current.LineNo;
+        this.dataStack.push(node);
+        return;
+    }
     let rVal = this.dataStack.pop();
     let lVal = this.dataStack.pop();
     let op = AST.ASTBinary.from_binary_op(this.code.Current.Argument);

package/lib/handlers/comparisons.js

@@ -33,17 +33,10 @@ function handleCompareOpA() {
     let left = this.dataStack.pop();
     let arg = this.code.Current.Argument;
     if (this.object.Reader.versionCompare(3, 13) >= 0) {
-        // Python 3.13 encodes the comparison in packed form; map observed
-        // specializations back to standard compare ops.
-        const mapped = {
-            18: AST.ASTCompare.CompareOp.Less,         // guards: n < 0
-            72: AST.ASTCompare.CompareOp.Equal,        // len == N
-            88: AST.ASTCompare.CompareOp.Equal,        // literal == value
-            148: AST.ASTCompare.CompareOp.Greater      // guards: n > 0
-        };
-        arg = mapped[arg] ?? (arg & 0x0F);
+        // Py3.13: oparg = (op << 5) | (cast_bool<<4) | cache_flags. op ∈ 0..5.
+        arg >>= 5;
     } else if (this.object.Reader.versionCompare(3, 12) >= 0) {
-        // 3.12 quickened form stores compare op in high nibble
+        // Py3.12: oparg = (op << 4) | cache_flags. op ∈ 0..5.
         arg >>= 4;
     }
 

package/lib/handlers/exceptions_blocks.js

@@ -477,7 +477,8 @@ function handlePopExcept() {
         this.curBlock = this.defBlock || exceptBlock;
     }
 
-    let bodyNode = exceptBlock.nodes;
+    // exceptBlock.nodes returns the block's m_nodes array directly (getter with no setter).
+    let bodyNodes = exceptBlock.nodes;
 
     if (this.curBlock.blockType == AST.ASTBlock.BlockType.Try) {
         const pendingEgType = this.egMatchTypeStack?.shift?.() || this.pendingEgMatchType;
@@ -502,7 +503,11 @@ function handlePopExcept() {
         }
         let catchBlock = new AST.ASTCondBlock(AST.ASTBlock.BlockType.Except, exceptBlock.start, exceptBlock.end, matchType, false);
         catchBlock.line = exceptBlock.line;
-        catchBlock.nodes = bodyNode.nodes;
+        // Copy the handler body from the popped Except. `nodes` is getter-only,
+        // so mutate m_nodes directly — plain assignment here silently no-ops.
+        if (Array.isArray(bodyNodes) && bodyNodes.length) {
+            catchBlock.m_nodes.push(...bodyNodes);
+        }
         catchBlock.isExceptStar = isExceptStar;
         if (catchBlock.condition && typeof catchBlock.condition === 'object' && 'src' in catchBlock.condition) {
             const storeSrc = catchBlock.condition.src;

package/lib/handlers/function_calls.js

@@ -297,7 +297,10 @@ function handleInstrumentedCallA() {
             const topType = sourceTop?.constructor?.name || 'null';
             console.log(`[CALL] func=${codeObj?.Name || codeObj?.QualName?.Value || '<?>'} sourceTop=${topType} compNode=${compNode?.constructor?.name || 'null'} hasSource=${!!codeObj?.SourceCode} pparams=${pparamList.length}`);
         }
-        const looksLikeComp = compNames.has(func.code?.object?.Name) ||
+        // Name is a PythonObject (Py_String/Py_Unicode), not a raw string — compare
+        // via toString() so the Set lookup actually matches.
+        const codeName = func.code?.object?.Name?.toString?.() || '';
+        const looksLikeComp = compNames.has(codeName) ||
                               sourceTop instanceof AST.ASTComprehension ||
                               compNode instanceof AST.ASTComprehension ||
                               (sourceTop instanceof AST.ASTReturn && sourceTop.value instanceof AST.ASTComprehension);
@@ -313,6 +316,15 @@ function handleInstrumentedCallA() {
             if (!(resultNode instanceof AST.ASTComprehension) && codeObj?.SourceCode) {
                 let yieldExpr = null;
                 let loopVar = null;
+                // Seed async-ness from the code flags: async comprehensions and
+                // async generator expressions carry CO_ASYNC_GENERATOR /
+                // CO_COROUTINE on the inner code object, so use that as the
+                // default in case the inner tree lacks an explicit AsyncFor
+                // block (e.g. pre-3.8 async comprehensions use GET_ANEXT +
+                // STORE instead of a FOR_ITER-driven iter block).
+                const flags = codeObj?.Flags | 0;
+                let isAsyncLoop = !!(flags & AST.ASTFunction.CodeFlags.CO_ASYNC_GENERATOR) ||
+                                  !!(flags & AST.ASTFunction.CodeFlags.CO_COROUTINE);
                 const searchNodes = (nodes) => {
                     if (!nodes) return;
                     for (const node of nodes) {
@@ -322,8 +334,13 @@ function handleInstrumentedCallA() {
                         if (node instanceof AST.ASTStore && !loopVar) {
                             loopVar = node.dest;
                         }
-                        if (node instanceof AST.ASTIterBlock && node.blockType === AST.ASTBlock.BlockType.AsyncFor) {
-                            if (node.index) loopVar = node.index;
+                        if (node instanceof AST.ASTIterBlock &&
+                            (node.blockType === AST.ASTBlock.BlockType.AsyncFor ||
+                             node.blockType === AST.ASTBlock.BlockType.For)) {
+                            if (node.index) {
+                                loopVar = node.index;
+                                isAsyncLoop = (node.blockType === AST.ASTBlock.BlockType.AsyncFor);
+                            }
                             if (node.nodes) searchNodes(node.nodes);
                         }
                         if (node?.nodes) searchNodes(node.nodes);
@@ -356,13 +373,14 @@ function handleInstrumentedCallA() {
                             const varName = op.Name?.toString?.() || '';
                             if (varName) {
                                 loopVar = new AST.ASTName(varName);
+                                isAsyncLoop = true;
                                 break;
                             }
                         }
                     }
                 }
                 if (global.g_cliArgs?.debug) {
-                    console.log(`[CALL-RECONSTRUCT] ${codeObj.Name?.toString?.()} yield=${yieldExpr?.constructor?.name} loopVar=${loopVar?.name}`);
+                    console.log(`[CALL-RECONSTRUCT] ${codeObj.Name?.toString?.()} yield=${yieldExpr?.constructor?.name} loopVar=${loopVar?.name} isAsyncLoop=${isAsyncLoop}`);
                 }
                 if (yieldExpr && loopVar) {
                     let kind = AST.ASTComprehension.GENERATOR;
@@ -377,7 +395,8 @@ function handleInstrumentedCallA() {
                         comp = new AST.ASTComprehension(yieldExpr);
                     }
                     comp.kind = kind;
-                    let gen = new AST.ASTIterBlock(AST.ASTBlock.BlockType.AsyncFor, 0, 0, new AST.ASTName('.0'));
+                    const genBlockType = isAsyncLoop ? AST.ASTBlock.BlockType.AsyncFor : AST.ASTBlock.BlockType.For;
+                    let gen = new AST.ASTIterBlock(genBlockType, 0, 0, new AST.ASTName('.0'));
                     gen.index = loopVar;
                     gen.comprehension = true;
                     comp.addGenerator(gen);

package/lib/handlers/function_class_build.js

@@ -379,7 +379,17 @@ function handleBuildConstKeyMapA() {
 function handleBuildStringA() {
     let values = [];
     for (let idx = 0; idx < this.code.Current.Argument; idx++) {
-        values.push(this.dataStack.pop());
+        let v = this.dataStack.pop();
+        // Unwrap premature single-FormattedValue JoinedStr wrappers. These arise
+        // when FORMAT_SIMPLE's lookahead (hasUpcomingStringBuild) bailed early
+        // on a CALL_A that actually belongs to a later interpolation in this
+        // same BUILD_STRING — rendering the wrapper would otherwise produce
+        // `f"f"{expr}""` nested inside the outer f-string.
+        if (v instanceof AST.ASTJoinedStr && v.values && v.values.length === 1 &&
+            v.values[0] instanceof AST.ASTFormattedValue) {
+            v = v.values[0];
+        }
+        values.push(v);
     }
 
     let stringNode = new AST.ASTJoinedStr(values);

package/lib/handlers/load_store_names.js

@@ -182,6 +182,22 @@ function handleLoadGlobalA() {
     this.dataStack.push(node);
 }
 
+function handleLoadFromDictOrGlobalsA() {
+    // Python 3.12+: pops the class-body locals dict pushed by LOAD_LOCALS,
+    // looks up co_names[A] there, falling back to globals. For source
+    // reconstruction we render it as a bare name reference.
+    if (this.dataStack.top() instanceof AST.ASTLocals) {
+        this.dataStack.pop();
+    }
+    const varName = this.code.Current.Name || "";
+    if (!varName.length) {
+        return;
+    }
+    let node = new AST.ASTName(varName);
+    node.line = this.code.Current.LineNo;
+    this.dataStack.push(node);
+}
+
 function handleLoadFromDictOrDerefA() {
     // Python 3.12+: LOAD_FROM_DICT_OR_DEREF consumes the locals dict from TOS
     // (pushed by the preceding LOAD_LOCALS) and resolves the name against it,
@@ -253,9 +269,15 @@ function handleLoadSpecialA() {
     }
 
     // For __exit__ (oparg 1): save the context manager expression for with-block
-    // This is called BEFORE __enter__ in 3.14 bytecode pattern
+    // This is called BEFORE __enter__ in 3.14 bytecode pattern.
+    // The 3.14 with-prologue uses LOAD_FAST(ctx); COPY 1; LOAD_SPECIAL 1, which
+    // looks like the LOAD+COPY 1 match-subject idiom — clear the candidate so
+    // a later COMPARE_OP inside the with-body doesn't get wrapped in a
+    // synthetic `match ctx:` rooted on the context manager.
     if (oparg === 1) {
         this._py314WithContextMgr = obj;
+        this.potentialMatchSubject = null;
+        this.matchCandidateStart = -1;
     }
 
     // For __enter__ (oparg 0): create with-block using saved context manager
@@ -478,6 +500,28 @@ function processStore(nameOverride) {
         }
     }
 
+    // `case _ as name:` final clause: no preceding pattern ops, no LOAD
+    // before the STORE, and we're inside a match. CPython emits a bare STORE
+    // to bind the subject still living on the stack.
+    if (this.currentMatch && !this.currentCase && !this.inMatchPattern &&
+        (this.patternOps?.length || 0) === 0) {
+        const prevId = this.code.Prev?.OpCodeID;
+        const isAfterReturn = prevId == this.OpCodes.RETURN_VALUE ||
+                              prevId == this.OpCodes.RETURN_VALUE_A ||
+                              prevId == this.OpCodes.RETURN_CONST_A;
+        if (isAfterReturn) {
+            const wildcard = new AST.ASTPattern(AST.ASTPattern.PatternType.Wildcard, '_');
+            const asPattern = new AST.ASTPattern(AST.ASTPattern.PatternType.As, {
+                pattern: wildcard,
+                name: currentName
+            });
+            this.currentCase = new AST.ASTCase(asPattern, null, null);
+            this.currentCase.line = this.code.Current.LineNo;
+            this.caseBodyStartIndex = this.curBlock?.nodes?.length || 0;
+            return;
+        }
+    }
+
     if (global.g_cliArgs?.debug && currentName && (currentName === 'b' || currentName === 'i')) {
         console.log(`[processStore] varName=${currentName}, curBlock=${this.curBlock.type_str}, inited=${this.curBlock.inited}, unpack=${this.unpack}`);
         console.log(`  Block stack: ${this.blocks.map((b,i) => `[${i}]${b.type_str}(inited=${b.inited})`).join(' → ')}`);
@@ -832,6 +876,7 @@ module.exports = {
     handleLoadZeroSuperAttrA,
     handleLoadZeroSuperMethodA,
     handleLoadFromDictOrDerefA,
+    handleLoadFromDictOrGlobalsA,
     handleStoreAttrA,
     handleStoreDerefA,
     handleStoreFastA,