depyo 1.0.3 → 1.1.0

package/lib/PycDecompiler.js

@@ -150,6 +150,8 @@ class PycDecompiler {
         this.enrichGenericAnnotations(functonBody);
         this.rewriteClassDefinitions(functonBody);
         this.removeNullSentinelComparisons(functonBody);
+        this.cleanupExcMatchArtifacts(functonBody);
+        this.hoistNestedExceptBlocks(functonBody);
         this.dedupeExceptHandlers(functonBody);
         this.removeDuplicateReturns(functonBody);
 
@@ -428,7 +430,19 @@ class PycDecompiler {
         if (offset === undefined) {
             return;
         }
-        const maxHandlerEnd = this.maxExceptionHandlerEnd || Math.max(...entries.filter(e => e.depth > 0).map(e => e.end || 0), 0);
+        // Exclude cleanup-only handler entries (depth>0 whose start is a RERAISE site,
+        // not a PUSH_EXC_INFO) from the try-block span. Those entries protect CPython's
+        // implicit re-raise tail, not a user-written except, and must not be treated
+        // as handler bodies when sizing the enclosing try.
+        const isUserHandlerEntry = (e) => {
+            if (!e || e.depth <= 0) return false;
+            const startInstr = this.code.PeekInstructionAtOffset(e.start);
+            return startInstr && startInstr.OpCodeID === this.OpCodes.PUSH_EXC_INFO;
+        };
+        const maxHandlerEnd = this.maxExceptionHandlerEnd || Math.max(
+            ...entries.filter(e => e.depth > 0 && isUserHandlerEntry(e)).map(e => e.end || 0),
+            0
+        );
 
         // Build set of WITH_EXCEPT_START handler ranges (lazily, once per code object)
         if (!this._withExceptRanges) {
@@ -579,6 +593,16 @@ class PycDecompiler {
                     }
                 }
             }
+            // Skip depth>0 entries whose start is a RERAISE cleanup site rather than
+            // a user-level PUSH_EXC_INFO handler. These appear in CPython 3.11+ as
+            // protected tails around `RERAISE 0` or `COPY n; POP_EXCEPT; RERAISE 1`
+            // and have no source-level except counterpart.
+            if (entry.depth > 0 && !isUserHandlerEntry(entry)) {
+                if (g_cliArgs?.debug) {
+                    console.log(`[EnsureExcBlocks] Skipping cleanup-only handler entry at ${entry.start} (not PUSH_EXC_INFO)`);
+                }
+                continue;
+            }
             const handlerEnd = entry.depth === 0
                 ? (maxHandlerEnd || entry.end || this.code.LastOffset || this.object.CodeSize || 0)
                 : (entry.end || maxHandlerEnd || this.code.LastOffset || this.object.CodeSize || 0);
@@ -644,6 +668,54 @@ class PycDecompiler {
             if (!next) break;
             end = next.end;
         }
+        // The exception-table entry only covers the prologue (the protected
+        // region around CHECK_EXC_MATCH). The actual handler body — user
+        // statements, POP_EXCEPT, and the terminating exit — lives past the
+        // entry end. Walk forward to include POP_EXCEPT and the following
+        // terminator (RETURN/JUMP_FORWARD/RERAISE) so the Except block
+        // captures the body that renders as user code.
+        if (this.code && this.OpCodes) {
+            let cursor = end;
+            let steps = 0;
+            let sawHandlerExit = false;
+            while (cursor >= 0 && steps++ < 500) {
+                const instr = this.code.PeekInstructionAtOffset(cursor);
+                if (!instr) break;
+                const op = instr.OpCodeID;
+                // Stop if we enter another handler's prologue.
+                if (op === this.OpCodes.PUSH_EXC_INFO) break;
+                if (op === this.OpCodes.POP_EXCEPT) {
+                    sawHandlerExit = true;
+                    end = instr.Offset + (instr.Size || 2);
+                    cursor = end;
+                    continue;
+                }
+                if (sawHandlerExit && (
+                    op === this.OpCodes.RETURN_VALUE ||
+                    op === this.OpCodes.RETURN_VALUE_A ||
+                    op === this.OpCodes.RETURN_CONST_A ||
+                    op === this.OpCodes.JUMP_FORWARD ||
+                    op === this.OpCodes.JUMP_FORWARD_A ||
+                    op === this.OpCodes.JUMP_BACKWARD ||
+                    op === this.OpCodes.JUMP_BACKWARD_A ||
+                    op === this.OpCodes.RERAISE ||
+                    op === this.OpCodes.RERAISE_A)) {
+                    end = instr.Offset + (instr.Size || 2);
+                    break;
+                }
+                if (sawHandlerExit) {
+                    // Skip trailing CACHE/POP_TOP cleanup that sometimes sits
+                    // between POP_EXCEPT and the terminator on 3.11+.
+                    if (op === this.OpCodes.CACHE ||
+                        op === this.OpCodes.POP_TOP) {
+                        cursor = instr.Offset + (instr.Size || 2);
+                        continue;
+                    }
+                    break;
+                }
+                cursor = instr.Offset + (instr.Size || 2);
+            }
+        }
         return end;
     }
     
@@ -1653,11 +1725,45 @@ class PycDecompiler {
             if (hasDataclass) {
                 node.addDecorator(new AST.ASTName('dataclass'));
             }
+        } else if (node.src instanceof AST.ASTCall && this.isDecoratedClassCall(node.src)) {
+            // Pattern: `Name = decorator(ClassLiteral[, ...])` produced by Py3.12+
+            // dataclass/decorator-of-class flows. Promote to a real class with
+            // the call-of-decorator attached as an @decorator.
+            const call = node.src;
+            const classNode = call.pparams[0];
+            const decoratorExpr = this._buildDecoratorExpr(call);
+            node.src = classNode;
+            this.cleanupClassBody(classNode);
+            if (decoratorExpr) {
+                node.addDecorator(decoratorExpr);
+            }
         } else if (node.src instanceof AST.ASTClass) {
             this.cleanupClassBody(node.src);
         }
     }
 
+    isDecoratedClassCall(call) {
+        if (!(call instanceof AST.ASTCall)) return false;
+        if (call.func instanceof AST.ASTClass) return false;
+        if (!call.pparams || call.pparams.length < 1) return false;
+        if (!(call.pparams[0] instanceof AST.ASTClass)) return false;
+        // Any further pparams would become positional args to the decorator,
+        // which cannot be expressed as `@decorator(class)` sugar. Reject.
+        return call.pparams.length === 1;
+    }
+
+    _buildDecoratorExpr(call) {
+        // `decorator(class)` → `@decorator`
+        // `decorator(class, kw=val, ...)` → `@decorator(kw=val, ...)`
+        const kwargs = call.kwparams || [];
+        if (kwargs.length === 0 && !call.hasVar && !call.hasKw) {
+            return call.func;
+        }
+        const wrapper = new AST.ASTCall(call.func, [], kwargs);
+        wrapper.line = call.line;
+        return wrapper;
+    }
+
     _childContainers(node) {
         const containers = [];
         if (node instanceof AST.ASTBlock) {
@@ -1801,6 +1907,539 @@ class PycDecompiler {
         }
     }
 
+    // Rewrites 3.11+ CHECK_EXC_MATCH artifacts that leaked past block
+    // reconstruction: unwraps `except <exc> EXC_MATCH <type>` conditions
+    // down to `<type>`, rewrites sibling `while __exception__ EXC_MATCH T:`
+    // blocks into `except T:` handlers on the preceding Try, and strips
+    // trailing compiler-generated reraise/cleanup nodes (bare `raise`,
+    // `e = None; del e`, empty `try: pass`). Runs once on the whole tree.
+    cleanupExcMatchArtifacts(root) {
+        // CHECK_EXC_MATCH only exists in Py3.11+; earlier versions never produce
+        // the EXC_MATCH compare op or the __exception__ sentinel, so skip.
+        if (this.object.Reader.versionCompare(3, 11) < 0) return;
+
+        const EXC_MATCH = AST.ASTCompare.CompareOp.Exception;
+
+        const unwrapExcMatch = (cond) => {
+            if (!cond) return cond;
+            // The condition may have been wrapped in ASTStore (alias binding) -
+            // unwrap first, then strip the EXC_MATCH compare.
+            let inner = cond;
+            if (inner instanceof AST.ASTStore && inner.src) {
+                inner = inner.src;
+            }
+            if (inner instanceof AST.ASTCompare && inner.op === EXC_MATCH) {
+                return inner.right;
+            }
+            return cond;
+        };
+
+        const isExcMatchCompare = (node) =>
+            node instanceof AST.ASTCompare && node.op === EXC_MATCH;
+
+        const isExceptionName = (node) =>
+            node instanceof AST.ASTName && node.name === '__exception__';
+
+        const containsExceptionRef = (node, depth = 0) => {
+            if (!node || depth > 4) return false;
+            if (isExceptionName(node)) return true;
+            if (node instanceof AST.ASTCompare || node instanceof AST.ASTBinary) {
+                return containsExceptionRef(node.left, depth + 1) ||
+                       containsExceptionRef(node.right, depth + 1);
+            }
+            if (node instanceof AST.ASTCall) {
+                return containsExceptionRef(node.func, depth + 1) ||
+                       (node.pparams || []).some(p => containsExceptionRef(p, depth + 1));
+            }
+            if (node instanceof AST.ASTStore) {
+                return containsExceptionRef(node.src, depth + 1);
+            }
+            return false;
+        };
+
+        const isEmptyTryBlock = (node) =>
+            node instanceof AST.ASTBlock &&
+            node.blockType === AST.ASTBlock.BlockType.Try &&
+            (node.nodes.length === 0 ||
+             (node.nodes.length === 1 &&
+              node.nodes[0] instanceof AST.ASTKeyword &&
+              node.nodes[0].key === AST.ASTKeyword.Word.Pass));
+
+        const isOrphanExceptionStmt = (node) => {
+            // Bare `raise` with no params → fall-through RERAISE artifact
+            if (node instanceof AST.ASTRaise && (!node.params || node.params.length === 0)) {
+                return true;
+            }
+            // `__exception__(None, None, None)` or `__exception__` alone
+            if (node instanceof AST.ASTCall && isExceptionName(node.func)) {
+                return true;
+            }
+            if (isExceptionName(node)) {
+                return true;
+            }
+            // `x = __exception__` - CPython alias-clear artifact
+            if (node instanceof AST.ASTStore && isExceptionName(node.src)) {
+                return true;
+            }
+            // `return __exception__` - misrendered reraise epilogue
+            if (node instanceof AST.ASTReturn && isExceptionName(node.value)) {
+                return true;
+            }
+            return false;
+        };
+
+        const rewriteContainer = (nodes, parentBlockType) => {
+            if (!Array.isArray(nodes)) return;
+
+            // Pass 1: unwrap EXC_MATCH in Except block conditions.
+            for (const node of nodes) {
+                if (node instanceof AST.ASTCondBlock &&
+                    node.blockType === AST.ASTBlock.BlockType.Except) {
+                    node.condition = unwrapExcMatch(node.condition);
+                }
+            }
+
+            // Pass 2: convert ASTWhile/ASTIf with EXC_MATCH condition to Except
+            // handlers and attach them to the preceding Try block. If no preceding
+            // Try exists (deeply misparsed region), drop them to avoid invalid output.
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const node = nodes[i];
+                if (!(node instanceof AST.ASTCondBlock) ||
+                    !(node.blockType === AST.ASTBlock.BlockType.While ||
+                      node.blockType === AST.ASTBlock.BlockType.If)) {
+                    continue;
+                }
+                if (!isExcMatchCompare(node.condition) ||
+                    !containsExceptionRef(node.condition.left)) {
+                    continue;
+                }
+                const matchType = node.condition.right;
+                // Find nearest preceding Try block in this container.
+                let tryIdx = -1;
+                for (let j = i - 1; j >= 0; j--) {
+                    const cand = nodes[j];
+                    if (cand instanceof AST.ASTBlock &&
+                        cand.blockType === AST.ASTBlock.BlockType.Try) {
+                        tryIdx = j;
+                        break;
+                    }
+                    // Allow existing Except handlers between; skip past them.
+                    if (cand instanceof AST.ASTCondBlock &&
+                        cand.blockType === AST.ASTBlock.BlockType.Except) {
+                        continue;
+                    }
+                    break;
+                }
+                // Strip any trailing orphan reraise/alias-clear statements from body.
+                const cleanBody = node.nodes.filter(n => !isOrphanExceptionStmt(n));
+                if (cleanBody.length === 0) {
+                    cleanBody.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                }
+
+                if (tryIdx >= 0) {
+                    const exceptBlk = new AST.ASTCondBlock(
+                        AST.ASTBlock.BlockType.Except,
+                        node.start, node.end, matchType, false);
+                    exceptBlk.line = node.line;
+                    exceptBlk.m_nodes = cleanBody;
+                    // Insert right after last existing Except handler for that Try.
+                    let insertAt = tryIdx + 1;
+                    while (insertAt < nodes.length &&
+                           nodes[insertAt] instanceof AST.ASTCondBlock &&
+                           nodes[insertAt].blockType === AST.ASTBlock.BlockType.Except) {
+                        insertAt++;
+                    }
+                    nodes.splice(i, 1);
+                    if (insertAt > i) insertAt--;
+                    nodes.splice(insertAt, 0, exceptBlk);
+                } else {
+                    // No Try to attach to — dropping keeps output parseable.
+                    nodes.splice(i, 1);
+                }
+            }
+
+            // Pass 3: strip orphan exception-related statements at container
+            // level — but NOT inside Except/Finally bodies, where bare `raise`
+            // is a legitimate re-raise statement.
+            const inHandlerBody = parentBlockType === AST.ASTBlock.BlockType.Except ||
+                                  parentBlockType === AST.ASTBlock.BlockType.Finally;
+            if (!inHandlerBody) {
+                for (let i = nodes.length - 1; i >= 0; i--) {
+                    if (isOrphanExceptionStmt(nodes[i])) {
+                        nodes.splice(i, 1);
+                    }
+                }
+            }
+
+            // Pass 3.5: strip `X = None; del X` pairs — CPython 3.11+ emits this
+            // at the tail/fall-through of every `except Foo as X:` body to clear
+            // the binding. The pattern is synthetic and user code effectively
+            // never writes it literally, so removing it is safe and prevents
+            // the artifact from breaking up adjacent except clauses.
+            for (let i = nodes.length - 2; i >= 0; i--) {
+                const a = nodes[i], b = nodes[i + 1];
+                if (a instanceof AST.ASTStore &&
+                    a.src instanceof AST.ASTNone &&
+                    a.dest instanceof AST.ASTName &&
+                    b instanceof AST.ASTDelete &&
+                    b.value instanceof AST.ASTName &&
+                    a.dest.name === b.value.name) {
+                    nodes.splice(i, 2);
+                }
+            }
+
+            // Pass 4: drop empty `try:` blocks. With no following handler the
+            // try is a bare leftover. With a trivial `except: pass` handler the
+            // whole pair is a reconstruction artifact — Python forbids
+            // `try:<empty>`, so either outcome requires the try to go. When the
+            // handler has real body drop only the try and splice a `pass`
+            // placeholder into the handler's matching — but the current
+            // sightings all have pass-only handlers, so mirror that case.
+            const isTrivialHandlerBlock = (n) =>
+                n instanceof AST.ASTCondBlock &&
+                (n.blockType === AST.ASTBlock.BlockType.Except ||
+                 n.blockType === AST.ASTBlock.BlockType.Finally) &&
+                (n.nodes.length === 0 ||
+                 (n.nodes.length === 1 &&
+                  n.nodes[0] instanceof AST.ASTKeyword &&
+                  n.nodes[0].key === AST.ASTKeyword.Word.Pass));
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                if (!isEmptyTryBlock(nodes[i])) continue;
+                const next = nodes[i + 1];
+                const hasHandler = next instanceof AST.ASTCondBlock &&
+                    (next.blockType === AST.ASTBlock.BlockType.Except ||
+                     next.blockType === AST.ASTBlock.BlockType.Finally);
+                if (!hasHandler) {
+                    nodes.splice(i, 1);
+                    continue;
+                }
+                // Walk all trailing handlers; drop the whole cluster iff every
+                // one is a trivial pass-body — keeping any would still leave
+                // the empty try as a syntax error anyway.
+                let tailEnd = i + 1;
+                while (tailEnd < nodes.length && isTrivialHandlerBlock(nodes[tailEnd])) {
+                    tailEnd++;
+                }
+                const allTrivial = tailEnd > i + 1 &&
+                    nodes.slice(i + 1, tailEnd).every(isTrivialHandlerBlock) &&
+                    (tailEnd === nodes.length ||
+                     !(nodes[tailEnd] instanceof AST.ASTCondBlock &&
+                       (nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Except ||
+                        nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Finally)));
+                if (allTrivial) {
+                    nodes.splice(i, tailEnd - i);
+                }
+            }
+
+            // Pass 4.5: move a sibling Except/Finally that immediately follows
+            // a Try into the Try's body. When CFG reconstruction hoists the
+            // handler one level up (e.g. into the parent Else), the block
+            // renderer dedents `except:` to the parent's indent — producing
+            // `else: / try: / except:` where `except:` lands at the `else:`
+            // column instead of the `try:` column, which is a SyntaxError.
+            // Absorbing the handler into the Try body lets the renderer's
+            // single-step dedent land it at the correct `try:` column.
+            for (let i = 0; i < nodes.length - 1; i++) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTBlock) ||
+                    cur.blockType !== AST.ASTBlock.BlockType.Try) continue;
+                const next = nodes[i + 1];
+                if (!(next instanceof AST.ASTCondBlock)) continue;
+                if (next.blockType !== AST.ASTBlock.BlockType.Except &&
+                    next.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                // Skip if the Try already carries its own trailing handler —
+                // moving another one in would stack two handlers, which is
+                // only valid for multi-except chains (same Try). Those cases
+                // already render fine.
+                const last = cur.nodes[cur.nodes.length - 1];
+                const hasOwnHandler = last instanceof AST.ASTCondBlock &&
+                    (last.blockType === AST.ASTBlock.BlockType.Except ||
+                     last.blockType === AST.ASTBlock.BlockType.Finally);
+                if (hasOwnHandler) continue;
+                // Empty Try bodies + non-trivial handler would collapse to an
+                // invalid `try: / except:` with nothing between. Inject a
+                // `pass` so the rendered block is syntactically valid.
+                if (cur.nodes.length === 0) {
+                    cur.nodes.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                }
+                cur.nodes.push(next);
+                nodes.splice(i + 1, 1);
+            }
+
+            // Pass 5: a Try block with a non-empty body but no following
+            // Except/Finally handler is a SyntaxError. Append a synthetic
+            // `except: pass` so the output parses — real structural recovery
+            // needs dedicated work, but the fallback keeps the file usable.
+            // Skip when the Try already has an Except/Finally nested in its
+            // body (except* groups build nested handler structures).
+            for (let i = 0; i < nodes.length; i++) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTBlock) ||
+                    cur.blockType !== AST.ASTBlock.BlockType.Try) {
+                    continue;
+                }
+                if (cur.nodes.length === 0) continue;
+                const next = nodes[i + 1];
+                const hasHandler = next instanceof AST.ASTCondBlock &&
+                    (next.blockType === AST.ASTBlock.BlockType.Except ||
+                     next.blockType === AST.ASTBlock.BlockType.Finally);
+                if (hasHandler) continue;
+                const hasNestedExcept = cur.nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    (n.blockType === AST.ASTBlock.BlockType.Except ||
+                     n.blockType === AST.ASTBlock.BlockType.Finally));
+                if (hasNestedExcept) continue;
+                const synthetic = new AST.ASTCondBlock(
+                    AST.ASTBlock.BlockType.Except,
+                    cur.end, cur.end, null, false);
+                synthetic.line = cur.line;
+                synthetic.m_nodes.push(new AST.ASTKeyword(AST.ASTKeyword.Word.Pass));
+                nodes.splice(i + 1, 0, synthetic);
+                i++;
+            }
+
+            // Pass 5.5: adopt orphan Except into a preceding branch whose
+            // body ends with an un-paired Try. CPython can emit a try/except
+            // inside the tail of an if/else branch so that, after CFG
+            // reconstruction, the Try ends up as the last child of the branch
+            // while its handler gets hoisted one level up as a stray sibling.
+            // Moving the handler back in keeps the pair valid. Absorbed
+            // trailing statements stay in the handler body — not semantically
+            // correct, but renders to parseable Python instead of a stray
+            // `except:` at the outer indent.
+            const branchTypes = [
+                AST.ASTBlock.BlockType.If,
+                AST.ASTBlock.BlockType.Elif,
+                AST.ASTBlock.BlockType.Else,
+            ];
+            const endsWithOrphanTry = (block) => {
+                if (!(block instanceof AST.ASTBlock)) return false;
+                if (!branchTypes.includes(block.blockType)) return false;
+                const body = block.nodes;
+                if (!body || body.length === 0) return false;
+                const last = body[body.length - 1];
+                if (!(last instanceof AST.ASTBlock) ||
+                    last.blockType !== AST.ASTBlock.BlockType.Try) {
+                    return false;
+                }
+                const hasHandlerInside = last.nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    (n.blockType === AST.ASTBlock.BlockType.Except ||
+                     n.blockType === AST.ASTBlock.BlockType.Finally));
+                return !hasHandlerInside;
+            };
+            for (let i = nodes.length - 1; i > 0; i--) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTCondBlock)) continue;
+                if (cur.blockType !== AST.ASTBlock.BlockType.Except &&
+                    cur.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                const prev = nodes[i - 1];
+                if (!endsWithOrphanTry(prev)) continue;
+                // Confirm there's no matching Try at this container level,
+                // otherwise leave the pair alone.
+                let hasLocalTry = false;
+                for (let j = i - 1; j >= 0; j--) {
+                    const p = nodes[j];
+                    if (p instanceof AST.ASTBlock &&
+                        p.blockType === AST.ASTBlock.BlockType.Try) {
+                        hasLocalTry = true;
+                        break;
+                    }
+                    if (p instanceof AST.ASTCondBlock &&
+                        (p.blockType === AST.ASTBlock.BlockType.Except ||
+                         p.blockType === AST.ASTBlock.BlockType.Finally)) {
+                        continue;
+                    }
+                    break;
+                }
+                if (hasLocalTry) continue;
+                prev.nodes.push(cur);
+                nodes.splice(i, 1);
+            }
+
+            // Pass 6: drop orphan Except/Finally blocks that have no matching
+            // Try (or preceding Except) anywhere earlier in this container.
+            // These are leftovers from misreconstructed CFGs — keeping them
+            // produces SyntaxError at parse time. Inside a Try body Except
+            // can legitimately nest (Py3.11+ handler layout, except* groups),
+            // but only at the tail. A mid-body Except with non-handler
+            // statements after it is a stray handler — drop it.
+            const inTryBody = parentBlockType === AST.ASTBlock.BlockType.Try;
+            const isHandlerBlock = (x) =>
+                x instanceof AST.ASTCondBlock &&
+                (x.blockType === AST.ASTBlock.BlockType.Except ||
+                 x.blockType === AST.ASTBlock.BlockType.Finally);
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                const cur = nodes[i];
+                if (!(cur instanceof AST.ASTCondBlock)) continue;
+                if (cur.blockType !== AST.ASTBlock.BlockType.Except &&
+                    cur.blockType !== AST.ASTBlock.BlockType.Finally) continue;
+                if (inTryBody) {
+                    // except* groups have complex internal structure — never
+                    // touch them.
+                    if (cur.isExceptStar) continue;
+                    // For regular Except nested inside Try body (Py3.11+
+                    // handler layout): legitimate only when at the tail.
+                    let allTrailingHandlers = true;
+                    for (let k = i + 1; k < nodes.length; k++) {
+                        if (!isHandlerBlock(nodes[k])) {
+                            allTrailingHandlers = false;
+                            break;
+                        }
+                    }
+                    if (allTrailingHandlers) continue;
+                }
+                let anchorFound = false;
+                for (let j = i - 1; j >= 0; j--) {
+                    const prev = nodes[j];
+                    if (prev instanceof AST.ASTBlock &&
+                        prev.blockType === AST.ASTBlock.BlockType.Try) {
+                        anchorFound = true;
+                        break;
+                    }
+                    if (prev instanceof AST.ASTCondBlock &&
+                        (prev.blockType === AST.ASTBlock.BlockType.Except ||
+                         prev.blockType === AST.ASTBlock.BlockType.Finally)) {
+                        continue;
+                    }
+                    break;
+                }
+                if (!anchorFound) nodes.splice(i, 1);
+            }
+
+            // Pass 7: after earlier passes may have emptied a Try body, drop
+            // Try+trivial-Except pairs where the body is now empty. Python
+            // forbids `try:` with no body; a pass-only handler carries no
+            // recoverable intent, so splice the cluster out entirely.
+            for (let i = nodes.length - 1; i >= 0; i--) {
+                if (!isEmptyTryBlock(nodes[i])) continue;
+                let tailEnd = i + 1;
+                while (tailEnd < nodes.length && isTrivialHandlerBlock(nodes[tailEnd])) {
+                    tailEnd++;
+                }
+                if (tailEnd === i + 1) continue;
+                const trailingHandler = nodes[tailEnd] instanceof AST.ASTCondBlock &&
+                    (nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Except ||
+                     nodes[tailEnd].blockType === AST.ASTBlock.BlockType.Finally);
+                if (trailingHandler) continue;
+                nodes.splice(i, tailEnd - i);
+            }
+        };
+
+        // Post-order traversal: process children before parent so nested
+        // emptyings bubble up — an outer Try can only be recognised as empty
+        // after the inner Try/Except artifacts inside its body were dropped.
+        const visited = new WeakSet();
+        const visit = (n) => {
+            if (!n || visited.has(n)) return;
+            visited.add(n);
+            let nodes = null;
+            let parentType = null;
+            if (n instanceof AST.ASTNodeList) {
+                nodes = n.list;
+                parentType = null;
+            } else if (n instanceof AST.ASTBlock) {
+                nodes = n.nodes;
+                parentType = n.blockType;
+            } else if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                const body = n.src.code?.object?.SourceCode;
+                if (body) visit(body);
+                return;
+            }
+            if (nodes) {
+                for (const c of nodes) visit(c);
+                rewriteContainer(nodes, parentType);
+            }
+        };
+        visit(root);
+    }
+
+    // An Except block can get reconstructed inside a non-Try block's body
+    // (most often a For/While/If inside the protected try-body) when the
+    // handler's offset range overlaps a nested loop. Python requires the
+    // except clause to sit next to its `try:`, so walk the tree and pull
+    // such Except blocks out of any non-Try ancestor until they become a
+    // sibling of their enclosing Try.
+    hoistNestedExceptBlocks(root) {
+        const isHoistableBlock = (node) =>
+            node instanceof AST.ASTBlock &&
+            node.blockType !== AST.ASTBlock.BlockType.Try;
+
+        const isExcept = (node) =>
+            node instanceof AST.ASTCondBlock &&
+            node.blockType === AST.ASTBlock.BlockType.Except;
+
+        // Fixed-point loop: one pass hoists Except up one level. Bounded by
+        // tree depth; excessive iterations just exit.
+        for (let iter = 0; iter < 64; iter++) {
+            let moved = false;
+            const stack = [{container: null, nodes: null, parent: null}];
+            const parentMap = new WeakMap(); // child container → {arr, index, parent}
+
+            const visit = (arr, parentInfo) => {
+                for (let i = 0; i < arr.length; i++) {
+                    const n = arr[i];
+                    if (!n) continue;
+                    let children = null;
+                    if (n instanceof AST.ASTBlock || n instanceof AST.ASTCondBlock) {
+                        children = n.nodes;
+                    } else if (n instanceof AST.ASTNodeList) {
+                        children = n.list;
+                    } else if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                        const src = n.src.code?.object?.SourceCode;
+                        if (src instanceof AST.ASTNodeList) {
+                            visit(src.list, null);
+                        }
+                        continue;
+                    }
+                    if (Array.isArray(children) && children.length > 0) {
+                        // If this block is non-Try and its first child is an
+                        // Except, pull that Except out into the parent arr
+                        // right after `n`.
+                        if (isHoistableBlock(n)) {
+                            // Scan forward for leading Except children only;
+                            // an Except appearing later in the body is usually
+                            // a real construct we should leave alone.
+                            while (children.length > 0 && isExcept(children[0])) {
+                                const ex = children.shift();
+                                arr.splice(i + 1, 0, ex);
+                                moved = true;
+                            }
+                        }
+                        visit(children, {arr, index: i});
+                    }
+                }
+            };
+
+            const roots = [];
+            if (root instanceof AST.ASTNodeList) roots.push(root.list);
+            else if (root instanceof AST.ASTBlock) roots.push(root.nodes);
+
+            for (const r of roots) visit(r, null);
+
+            // Also dive into nested function bodies.
+            const walk = (n, seen) => {
+                if (!n || seen.has(n)) return;
+                seen.add(n);
+                if (n instanceof AST.ASTStore && n.src instanceof AST.ASTFunction) {
+                    const src = n.src.code?.object?.SourceCode;
+                    if (src instanceof AST.ASTNodeList) {
+                        visit(src.list, null);
+                    }
+                }
+                let children = null;
+                if (n instanceof AST.ASTNodeList) children = n.list;
+                else if (n instanceof AST.ASTBlock || n instanceof AST.ASTCondBlock) children = n.nodes;
+                if (Array.isArray(children)) {
+                    for (const c of children) walk(c, seen);
+                }
+            };
+            walk(root, new WeakSet());
+
+            if (!moved) break;
+        }
+    }
+
     dedupeExceptHandlers(root) {
         const queue = [root];
         const visited = new WeakSet();
@@ -2085,6 +2724,14 @@ class PycDecompiler {
                     const frag = ch?.codeFragment?.()?.toString?.() || "";
                     return frag === "pass" || frag.includes("__exception__") || frag.includes("##ERROR##");
                 }))) {
+                // Drop only synthetic except* handlers without a user condition.
+                // User-written `except:` / `except E:` must be preserved; replace
+                // cleanup-only body with `pass` so the try statement stays valid.
+                if (node.isExceptStar && !node.condition) {
+                    continue;
+                }
+                node.m_nodes = [new AST.ASTKeyword(AST.ASTKeyword.Word.Pass)];
+                rewritten.push(node);
                 continue;
             }
             if (typeof node?.codeFragment === 'function') {

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("'")) {

package/lib/ast/ast_node.js

@@ -258,7 +258,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 +477,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 +1119,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 +2561,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");
@@ -3137,12 +3173,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 +3214,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 +3250,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 +3291,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 +3303,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 +3315,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 +3341,9 @@ class ASTJoinedStr extends ASTNode {
             }
         }
 
-        result += '"';
+        if (!bareInnerForFormatSpec) {
+            result += quoteChar;
+        }
         return result;
     }
 

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/misc_other.js

@@ -582,7 +582,10 @@ function hasUpcomingStringBuild(context) {
         context.OpCodes.STORE_DEREF_A
     ]);
 
-    for (let step = 1; step <= 12; step++) {
+    // 3.11+ inline caches inflate the physical instruction stream; a single
+    // f-string with a few interpolations easily spans 30+ code slots before
+    // reaching BUILD_STRING. Cap generously and rely on earlyStops to bound.
+    for (let step = 1; step <= 48; step++) {
         const instr = context.code.PeekInstructionAtOffset(context.code.Current.Offset + step * 2);
         if (!instr) {
             break;
@@ -745,6 +748,28 @@ function handlePopTop() {
         return;
     }
 
+    // Mid-UNPACK_SEQUENCE POP_TOP: CPython emits `a, _, b = tup` as
+    // UNPACK 3 / STORE a / POP_TOP / STORE b, where POP_TOP drops the
+    // middle slot. Our unpack-state-machine accumulates STORE targets
+    // into a tuple; treat POP_TOP as an anonymous `_` slot so the
+    // remaining STORE_FAST still sees the tuple on the stack.
+    if (this.unpack > 0) {
+        let tupleNode = this.dataStack.top();
+        if (tupleNode instanceof AST.ASTTuple) {
+            let placeholder = new AST.ASTName("_");
+            if (this.starPos-- == 0) placeholder.name = "*_";
+            tupleNode.add(placeholder);
+            if (--this.unpack <= 0) {
+                this.dataStack.pop();
+                let seqNode = this.dataStack.pop();
+                let node = new AST.ASTStore(seqNode, tupleNode);
+                node.line = this.code.Current.LineNo;
+                this.curBlock.append(node);
+            }
+            return;
+        }
+    }
+
     if ([this.OpCodes.JUMP_ABSOLUTE_A, this.OpCodes.JUMP_FORWARD_A, this.OpCodes.POP_JUMP_IF_FALSE_A, this.OpCodes.JUMP_IF_FALSE_A].includes(this.code.Prev?.OpCodeID)) {
         if (this.curBlock.blockType == AST.ASTBlock.BlockType.Except) {
             // Skipping POP_TOP, POP_TOP, POP_TOP
@@ -1111,7 +1136,15 @@ function handleReturnConstA() {
                     nextOp.OpCodeID === this.OpCodes.RERAISE;
     const prevIsPOPExcept = this.code.Prev?.OpCodeID === this.OpCodes.POP_EXCEPT;
     const nextIsSWAP = nextOp?.OpCodeID === this.OpCodes.SWAP_A;
+    const nextIsRERAISE = nextOp?.OpCodeID === this.OpCodes.RERAISE ||
+                          nextOp?.OpCodeID === this.OpCodes.RERAISE_A;
     const isExceptCleanup = isNone && prevIsPOPExcept && nextIsSWAP;
+    // CPython 3.11+ places the function's implicit `return None` at the tail of an
+    // except handler (POP_EXCEPT → RETURN_CONST None → RERAISE or end-of-function).
+    // The source has no explicit return there; drop it so the handler body doesn't
+    // inherit a phantom return.
+    const isExceptTailImplicitReturn = isNone && prevIsPOPExcept &&
+                                        (nextIsRERAISE || !nextOp);
 
     if (isNone && isModuleLevel && isAtEnd) {
         return;  // Skip implicit return None at module end
@@ -1119,6 +1152,9 @@ function handleReturnConstA() {
     if (isExceptCleanup) {
         return;  // Skip return None in exception cleanup (except* success path)
     }
+    if (isExceptTailImplicitReturn) {
+        return;  // Skip synthetic return None at end of except handler
+    }
 
     let value = new AST.ASTObject(this.code.Current.ConstantObject);
     let node = new AST.ASTReturn(value);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "depyo",
-  "version": "1.0.3",
-  "description": "Python bytecode decompiler (Python 1.0–3.14) implemented in Node.js",
+  "version": "1.1.0",
+  "description": "Python bytecode decompiler (Python 1.0–3.15) implemented in Node.js",
   "bin": {
     "depyo": "./depyo.js"
   },