depyo 1.0.1 → 1.0.3

package/lib/PycDecompiler.js

@@ -1,6 +1,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const AST = require('./ast/ast_node');
+const { resolveBoolChainFrames } = require('./handlers/control_flow_jumps');
 
 Array.prototype.top = function ArrayTop (pos = 0) {
     return this[this.length - pos - 1];
@@ -13,6 +14,7 @@ Array.prototype.empty = function ArrayIsEmpty () {
 class PycDecompiler {
     static opCodeHandlers = {};
     cleanBuild = false;
+    errors = [];               // Per-opcode exceptions caught by main loop. Non-empty → cleanBuild=false.
     object = null;
     code = null;
 
@@ -97,21 +99,32 @@ class PycDecompiler {
                                 typeof fileExports[handlerName] === 'function' &&
                                 handlerName.startsWith("handle")) {
     
-                                // Convert handler name (e.g., "handleJumpForwardA") to opcode name ("JUMP_FORWARD_A")
-                                let opCodeName = handlerName.replace(/^handle/, '')
-                                                .replaceAll(/([A-Z][a-z]+)/g, m => m.toUpperCase() + '_')
-                                                .replace(/_$/, '');
+                                // Convert handler name (e.g., "handleJumpForwardA") to opcode name ("JUMP_FORWARD_A").
+                                // Primary rule: camelCase → SNAKE_CASE with explicit runs-of-caps handling
+                                // (HandleABCDef → ABC_DEF). Some legacy handlers like handleCallIntrinsic1A
+                                // still map via the looser regex — OpCodes.js provides both _1A and _1_A aliases.
+                                const body = handlerName.replace(/^handle/, '');
+                                let opCodeName = body
+                                    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+                                    .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+                                    .toUpperCase();
+                                if (!(opCodeName in OpCodesMap)) {
+                                    const legacy = body
+                                        .replaceAll(/([A-Z][a-z]+)/g, m => m.toUpperCase() + '_')
+                                        .replace(/_$/, '');
+                                    if (legacy in OpCodesMap) opCodeName = legacy;
+                                }
     
                                 if (opCodeName in OpCodesMap) {
                                     const opCodeId = OpCodesMap[opCodeName];
                                     const handlerFunc = fileExports[handlerName];
     
                                     if (PycDecompiler.opCodeHandlers[opCodeId]) {
-                                         console.warn(`Static Handler warning: OpCode ${opCodeName} (${opCodeId}) already has a handler. Overwriting.`);
+                                        throw new Error(`Static handler collision: OpCode ${opCodeName} (${opCodeId}) already bound; refusing silent overwrite from ${entry.name}:${handlerName}.`);
                                     }
                                     PycDecompiler.opCodeHandlers[opCodeId] = handlerFunc;
                                 } else {
-                                    console.warn(`Static Handler mapping warning: OpCode name "${opCodeName}" from ${entry.name} not found in OpCodes map.`);
+                                    throw new Error(`Static handler mapping failed: "${opCodeName}" (from ${entry.name}:${handlerName}) is not in OpCodes. Rename the handler to match a known opcode, or add the opcode to lib/OpCodes.js.`);
                                 }
                             }
                         }
@@ -140,6 +153,10 @@ class PycDecompiler {
         this.dedupeExceptHandlers(functonBody);
         this.removeDuplicateReturns(functonBody);
 
+        if (this.object.Name == "<lambda>") {
+            this.foldLambdaConditional(functonBody);
+        }
+
         if (this.object.Name != "<lambda>" && functonBody.last instanceof AST.ASTReturn && functonBody.last.value instanceof AST.ASTNone) {
             functonBody.list.pop();
         }
@@ -152,6 +169,81 @@ class PycDecompiler {
         return functonBody;
     }
 
+    foldLambdaConditional(body) {
+        // Lambda bodies must be single expressions. CPython often compiles a
+        // conditional expression `A if cond else B` as:
+        //   POP_JUMP_IF_FALSE X; LOAD A; RETURN_VALUE; X: LOAD B; RETURN_VALUE
+        // The decompiler's default path leaves this as two statements which is
+        // invalid Python inside a lambda. Detect the patterns and fold into a
+        // single ASTReturn(ASTTernary).
+        const list = body?.list;
+        if (!Array.isArray(list) || list.length !== 2) {
+            return;
+        }
+        const first = list[0];
+        const second = list[1];
+        if (!(second instanceof AST.ASTReturn)) {
+            return;
+        }
+        const elseVal = second.value;
+
+        const makeCondBlock = (condExpr, negative) => {
+            const cb = new AST.ASTCondBlock(AST.ASTBlock.BlockType.If, 0, 0, condExpr, !!negative);
+            return cb;
+        };
+
+        let tern = null;
+
+        // Case 1: first is `ASTReturn(ASTBinary(cond AND/OR val))` — the line-900
+        // collapse already ran. Recover cond/val/direction from the binary op.
+        if (first instanceof AST.ASTReturn && first.value instanceof AST.ASTBinary) {
+            const bin = first.value;
+            const isAnd = bin.op === AST.ASTBinary.BinOp.LogicalAnd;
+            const isOr = bin.op === AST.ASTBinary.BinOp.LogicalOr;
+            if (isAnd || isOr) {
+                const cond = bin.left;
+                const thenVal = bin.right;
+                const cb = makeCondBlock(cond, isOr);
+                tern = new AST.ASTTernary(cb, thenVal, elseVal);
+            }
+        }
+
+        // Case 2: first is an ASTCondBlock (if-return not collapsed by line 900).
+        if (!tern && first instanceof AST.ASTCondBlock &&
+            first.blockType === AST.ASTBlock.BlockType.If &&
+            Array.isArray(first.nodes) && first.nodes.length === 1 &&
+            first.nodes[0] instanceof AST.ASTReturn) {
+            const thenVal = first.nodes[0].value;
+            const cb = makeCondBlock(first.condition, first.negative);
+            tern = new AST.ASTTernary(cb, thenVal, elseVal);
+        }
+
+        if (!tern) {
+            // Two plain-return statements with no folded condition = optimizer
+            // eliminated the `if X else Y` when X was a constant, or the first
+            // return short-circuits the whole lambda (e.g. chained compare).
+            // The second return is unreachable; drop it so the lambda renders
+            // as a valid expression. Also covers generator lambdas where the
+            // yield expression is followed by the implicit `return None`.
+            const secondIsImplicitNone =
+                second instanceof AST.ASTReturn &&
+                second.rettype === AST.ASTReturn.RetType.Return &&
+                (!second.value || second.value instanceof AST.ASTNone);
+            if (first instanceof AST.ASTReturn &&
+                (first.rettype === AST.ASTReturn.RetType.Return || secondIsImplicitNone)) {
+                body.list.length = 1;
+                first.inLambda = true;
+            }
+            return;
+        }
+
+        const folded = new AST.ASTReturn(tern);
+        folded.inLambda = true;
+        folded.line = second.line ?? first.line;
+        body.list.length = 0;
+        body.list.push(folded);
+    }
+
     append_to_chain_store(chainStore, item)
     {
         if (this.dataStack.top() == item) {
@@ -243,6 +335,23 @@ class PycDecompiler {
         if (!(rit instanceof AST.ASTBlock) ||
             rit.blockType != AST.ASTBlock.BlockType.If)
             return;
+        // Peek before mutating: a real ternary needs both branches as expressions
+        // on the data stack. Otherwise the if/else are real statements (the bytecode
+        // path covers a control-flow if, not an if-expr) and rewriting them produces
+        // a ##ERROR## ternary that masks the real source.
+        const else_candidate = this.dataStack.top();
+        if (else_candidate == null) {
+            return;
+        }
+        const ifBlockCandidate = this.curBlock.nodes[this.curBlock.nodes.length - 2];
+        const stackDepth = this.dataStack.length;
+        const ifExprOnStack = stackDepth >= 2 ? this.dataStack[stackDepth - 2] : null;
+        const ifExprFromBody = ifExprOnStack == null && ifBlockCandidate.nodes.length == 1
+            ? ifBlockCandidate.nodes[0]
+            : ifExprOnStack;
+        if (ifExprFromBody == null) {
+            return;
+        }
         let else_expr = this.dataStack.pop();
         this.curBlock.removeLast();
         let if_block = this.curBlock.nodes.top();
@@ -520,7 +629,22 @@ class PycDecompiler {
         if (!matches.length) {
             return this.maxExceptionHandlerEnd || null;
         }
-        return Math.max(...matches.map(e => e.end));
+        let end = Math.max(...matches.map(e => e.end));
+        // CPython 3.11+ splits a single source-level except handler into
+        // contiguous depth>0 sub-regions (alias-binding, body, cleanup).
+        // Walk forward through adjacent depth>0 entries so the Except block
+        // covers the full handler body, not just the alias-binding region.
+        let guard = 0;
+        while (guard++ < 32) {
+            const next = entries.find(e =>
+                e.depth > 0 &&
+                e.start >= end &&
+                e.start <= end + 2 &&
+                e.end > end);
+            if (!next) break;
+            end = next.end;
+        }
+        return end;
     }
     
     statements () {
@@ -538,6 +662,83 @@ class PycDecompiler {
                 // Open blocks based on 3.11+ exception table (no SETUP_EXCEPT opcodes)
                 this.ensureExceptionTableBlocks();
 
+                // Early-return/raise in try body: CPython omits POP_BLOCK+JUMP_FORWARD,
+                // so the Try block is still open when we reach the except/finally handler.
+                // Close it and open Except/Finally here so handler prologue is consumed
+                // in the right block and __exception__ doesn't leak into Try.
+                if (this.code.Current.Offset > 0 && this.blocks.length > 1) {
+                    let tryIdx = -1, containerIdx = -1, isFinally = false;
+                    for (let i = this.blocks.length - 1; i >= 0; i--) {
+                        const blk = this.blocks[i];
+                        if (blk.blockType === AST.ASTBlock.BlockType.Container) {
+                            if (blk.hasExcept && blk.except === this.code.Current.Offset) {
+                                containerIdx = i;
+                                isFinally = false;
+                                break;
+                            }
+                            if (blk.hasFinally && !blk.hasExcept
+                                && blk.finally === this.code.Current.Offset) {
+                                containerIdx = i;
+                                isFinally = true;
+                                break;
+                            }
+                        }
+                        if (blk.blockType === AST.ASTBlock.BlockType.Try && tryIdx === -1) {
+                            tryIdx = i;
+                        }
+                    }
+                    if (containerIdx >= 0 && tryIdx > containerIdx
+                        && this.curBlock.blockType !== AST.ASTBlock.BlockType.Except
+                        && this.curBlock.blockType !== AST.ASTBlock.BlockType.Finally) {
+                        while (this.blocks.length - 1 > containerIdx) {
+                            const top = this.blocks[this.blocks.length - 1];
+                            this.blocks.pop();
+                            this.curBlock = this.blocks.top();
+                            this.curBlock.append(top);
+                        }
+                        const cont = this.curBlock;
+                        const handlerStart = isFinally ? cont.finally : cont.except;
+                        let handlerEnd = handlerStart;
+                        let cursor = handlerStart;
+                        for (let k = 0; k < 500; k++) {
+                            const instr = this.code.PeekInstructionAtOffset(cursor);
+                            if (!instr) break;
+                            const op = instr.OpCodeID;
+                            if (op === this.OpCodes.END_FINALLY
+                                || op === this.OpCodes.POP_EXCEPT
+                                || op === this.OpCodes.RERAISE_A
+                                || op === this.OpCodes.RERAISE) {
+                                handlerEnd = instr.Offset;
+                                break;
+                            }
+                            if (op === this.OpCodes.RETURN_VALUE
+                                || op === this.OpCodes.RETURN_VALUE_A
+                                || op === this.OpCodes.RETURN_CONST_A
+                                || op === this.OpCodes.RAISE_VARARGS_A) {
+                                handlerEnd = instr.Offset + (instr.Size || 2);
+                                break;
+                            }
+                            cursor = instr.Offset + (instr.Size || 2);
+                        }
+                        if (isFinally) {
+                            let finallyBlk = new AST.ASTBlock(AST.ASTBlock.BlockType.Finally, this.code.Current.Offset, handlerEnd, true);
+                            this.blocks.push(finallyBlk);
+                            this.curBlock = this.blocks.top();
+                            if (global.g_cliArgs?.debug) {
+                                console.log(`[EarlyReturnFinally] Opened Finally at ${this.code.Current.Offset}, handlerEnd=${handlerEnd}`);
+                            }
+                        } else {
+                            let except = new AST.ASTCondBlock(AST.ASTBlock.BlockType.Except, this.code.Current.Offset, handlerEnd, null, false);
+                            except.init();
+                            this.blocks.push(except);
+                            this.curBlock = this.blocks.top();
+                            if (global.g_cliArgs?.debug) {
+                                console.log(`[EarlyReturnExcept] Opened Except at ${this.code.Current.Offset}, handlerEnd=${handlerEnd}`);
+                            }
+                        }
+                    }
+                }
+
                 // Python 3.8: When entering exception handler, push exception instance to stack
                 if (this.exceptionHandlerOffsets.has(this.code.Current.Offset)) {
                     // Create synthetic exception instance placeholder
@@ -708,10 +909,33 @@ class PycDecompiler {
                     }
                 }
 
+                // Resolve any open boolean-expression chain frames whose target
+                // offset matches the current instruction. This folds pending
+                // JUMP_IF_FALSE/TRUE lhs+rhs pairs into ASTBinary AND/OR nodes
+                // and pushes the result onto dataStack before the consumer
+                // (STORE_*, RETURN_*, CALL_*, or a nested JUMP_IF_*) fires.
+                if (this.boolChainStack && this.boolChainStack.length > 0) {
+                    resolveBoolChainFrames(this, this.code.Current.Offset);
+                }
+
                 if (this.code.Current.OpCodeID in PycDecompiler.opCodeHandlers)
                 {
                     PycDecompiler.opCodeHandlers[this.code.Current.OpCodeID].call(this);
                 } else {
+                    // Unsupported opcode: bail out of the loop with what we have.
+                    // Record so `--strict` and the dirty-files report can surface it.
+                    this.errors.push({
+                        opcode: this.code.Current.InstructionName,
+                        argument: this.code.Current.Argument,
+                        offset: this.code.Current.Offset,
+                        fileOffset: this.object.codeOffset + this.code.Current.Offset,
+                        codeObject: this.object.Name,
+                        message: `Unsupported opcode ${this.code.Current.InstructionName}`,
+                        unsupported: true
+                    });
+                    if (global.g_cliArgs?.strict) {
+                        throw new Error(`Unsupported opcode ${this.code.Current.InstructionName} at offset ${this.code.Current.Offset}`);
+                    }
                     if (!g_cliArgs?.silent) {
                         console.error(`Unsupported opcode ${this.code.Current.InstructionName} at pos ${this.code.Current.Offset}\n`);
                     }
@@ -727,6 +951,21 @@ class PycDecompiler {
                         && (this.curBlock.end == this.code.Next?.Offset);
 
             } catch (ex) {
+                // Record the failure so callers can detect partial output. Without this
+                // accumulator the main loop swallows handler exceptions silently and
+                // cleanBuild gets reset to true at end-of-loop, masking corruption.
+                this.errors.push({
+                    opcode: this.code.Current.InstructionName,
+                    argument: this.code.Current.Argument,
+                    offset: this.code.Current.Offset,
+                    fileOffset: this.object.codeOffset + this.code.Current.Offset,
+                    codeObject: this.object.Name,
+                    message: ex.message,
+                    stack: ex.stack
+                });
+                if (global.g_cliArgs?.strict) {
+                    throw ex;
+                }
                 if (!g_cliArgs?.silent) {
                     console.error(`EXCEPTION for OpCode ${this.code.Current.InstructionName} (${this.code.Current.Argument}) at offset ${this.code.Current.Offset} in code object '${this.object.Name}', file offset ${this.object.codeOffset + this.code.Current.Offset} : ${ex.message}\n\n`);
                     if (global.g_cliArgs?.debug) {
@@ -764,7 +1003,7 @@ class PycDecompiler {
             }
         }
     
-        this.cleanBuild = true;
+        this.cleanBuild = this.errors.length === 0;
         let mainNode = new AST.ASTNodeList(this.defBlock.nodes);
         return mainNode;
     }
@@ -1123,10 +1362,19 @@ class PycDecompiler {
                 return true;
             });
             if (aliasName) {
-                const cond = matchType || blk.condition || new AST.ASTName("Exception");
-                blk.condition = new AST.ASTStore(cond, aliasName);
-                if (matchType) {
-                    blk.isExceptStar = true;
+                const existing = blk.condition;
+                if (existing instanceof AST.ASTStore) {
+                    // Condition already encodes `Type as alias` (set by misc_other.js
+                    // POP_TOP→STORE_FAST→POP_TOP path). Don't double-wrap.
+                    if (matchType) {
+                        blk.isExceptStar = true;
+                    }
+                } else {
+                    const cond = matchType || existing || new AST.ASTName("Exception");
+                    blk.condition = new AST.ASTStore(cond, aliasName);
+                    if (matchType) {
+                        blk.isExceptStar = true;
+                    }
                 }
             }
             if (blk.m_nodes.length > 3) {
@@ -1256,14 +1504,15 @@ class PycDecompiler {
                 const alias = node.condition instanceof AST.ASTStore ? node.condition.dest : null;
                 const filtered = (node.nodes || []).filter(n => !isCleanupNode(n, alias));
 
-                // If an except handler has been reduced to empty but still has a condition, keep it with 'pass'
-                // to preserve the handler rather than dropping it entirely.
-                if (node.condition && filtered.length === 0) {
+                // Only synthetic except* handlers without a condition AND no real body
+                // should be dropped; user-written `except:` and `except E:` blocks must
+                // be preserved (with `pass` if the body was nothing but cleanup).
+                if (filtered.length === 0) {
                     node.m_nodes = [new AST.ASTKeyword(AST.ASTKeyword.Word.Pass)];
                 } else if (filtered.length !== (node.nodes || []).length) {
                     node.m_nodes = filtered;
                 }
-                if (Array.isArray(parentArr) && (!node.nodes || node.nodes.length === 0)) {
+                if (Array.isArray(parentArr) && node.isExceptStar && !node.condition && filtered.length === 0) {
                     parentArr.splice(idx, 1);
                     continue;
                 }
@@ -1361,28 +1610,70 @@ class PycDecompiler {
     }
 
     rewriteClassDefinitions(root) {
-        if (!(root instanceof AST.ASTNodeList)) {
-            return;
-        }
+        const hasDataclass = (root instanceof AST.ASTNodeList) && this.astHasDataclassImport(root);
+        this._rewriteClassDefsInNodes(this._collectStatementNodes(root), hasDataclass, new Set());
+    }
+
+    _collectStatementNodes(container) {
+        if (!container) return [];
+        if (container instanceof AST.ASTNodeList) return container.list;
+        if (container instanceof AST.ASTBlock) return container.nodes;
+        return [];
+    }
 
-        const hasDataclass = this.astHasDataclassImport(root);
+    _rewriteClassDefsInNodes(nodes, hasDataclass, visited) {
+        if (!Array.isArray(nodes) || visited.has(nodes)) return;
+        visited.add(nodes);
 
-        for (const node of root.list) {
-            if (!(node instanceof AST.ASTStore)) {
-                continue;
+        for (const node of nodes) {
+            if (node instanceof AST.ASTStore) {
+                this._maybeRewriteClassStore(node, hasDataclass);
             }
+            for (const child of this._childContainers(node)) {
+                this._rewriteClassDefsInNodes(child, hasDataclass, visited);
+            }
+        }
+    }
 
-            if (node.src instanceof AST.ASTCall && node.src.func instanceof AST.ASTClass &&
-                this.isPlainClassCall(node.src)) {
-                node.src = node.src.func;
-                this.cleanupClassBody(node.src);
-                if (hasDataclass) {
-                    node.addDecorator(new AST.ASTName('dataclass'));
-                }
-            } else if (node.src instanceof AST.ASTClass) {
-                this.cleanupClassBody(node.src);
+    _maybeRewriteClassStore(node, hasDataclass) {
+        if (node.src instanceof AST.ASTCall && node.src.func instanceof AST.ASTClass &&
+            this.isPlainClassCall(node.src)) {
+            node.src = node.src.func;
+            this.cleanupClassBody(node.src);
+            if (hasDataclass) {
+                node.addDecorator(new AST.ASTName('dataclass'));
+            }
+        } else if (node.src instanceof AST.ASTCall && node.src.func instanceof AST.ASTClass &&
+                   this.isClassCallWithOnlyKwargs(node.src)) {
+            const callNode = node.src;
+            const classNode = callNode.func;
+            classNode.kwargs = callNode.kwparams || [];
+            node.src = classNode;
+            this.cleanupClassBody(classNode);
+            if (hasDataclass) {
+                node.addDecorator(new AST.ASTName('dataclass'));
+            }
+        } else if (node.src instanceof AST.ASTClass) {
+            this.cleanupClassBody(node.src);
+        }
+    }
+
+    _childContainers(node) {
+        const containers = [];
+        if (node instanceof AST.ASTBlock) {
+            containers.push(node.nodes);
+        }
+        if (node?.body && (node.body instanceof AST.ASTBlock || node.body instanceof AST.ASTNodeList)) {
+            containers.push(this._collectStatementNodes(node.body));
+        }
+        // Generic walk for nested blocks/lists in object properties (e.g. ifBlock.elseBlock).
+        for (const key of ['elseBlock', 'finallyBlock', 'tryBlock', 'thenBlock']) {
+            const val = node?.[key];
+            if (val instanceof AST.ASTBlock || val instanceof AST.ASTNodeList) {
+                containers.push(this._collectStatementNodes(val));
             }
         }
+        return containers;
     }
 
     isPlainClassCall(call) {
@@ -1395,6 +1686,15 @@ class PycDecompiler {
         return !hasParams;
     }
 
+    isClassCallWithOnlyKwargs(call) {
+        if (!(call.func instanceof AST.ASTClass)) {
+            return false;
+        }
+        const hasPparams = call.pparams && call.pparams.length > 0;
+        const hasKwparams = call.kwparams && call.kwparams.length > 0;
+        return !hasPparams && hasKwparams && !call.hasVar && !call.hasKw;
+    }
+
     astHasDataclassImport(root) {
         if (!(root instanceof AST.ASTNodeList)) {
             return false;
@@ -1520,12 +1820,23 @@ class PycDecompiler {
                     }
                 }
 
-                // Drop trivial generic except handlers that only contain pass/cleanup.
+                // Drop trivial generic except* handlers (exception-group artifacts) that only contain pass/cleanup.
+                // User-written `except:` and `except Exception:` must be preserved.
+                // Python forbids mixing `except` and `except*` inside the same try, so a
+                // non-star trivial `except Exception [as X]: pass` in a try that has any
+                // `except*` sibling is always a decompiler artifact.
+                const hasExceptStarSibling = nodes.some(n =>
+                    n instanceof AST.ASTCondBlock &&
+                    n.blockType === AST.ASTBlock.BlockType.Except &&
+                    n.isExceptStar);
                 for (let i = nodes.length - 1; i >= 0; i--) {
                     const blk = nodes[i];
                     if (!(blk instanceof AST.ASTCondBlock) || blk.blockType !== AST.ASTBlock.BlockType.Except) {
                         continue;
                     }
+                    if (!blk.isExceptStar && !hasExceptStarSibling) {
+                        continue;
+                    }
                     const condNode = blk.condition instanceof AST.ASTStore ? blk.condition.src : blk.condition;
                     const condText = (typeof condNode?.codeFragment === 'function' ? condNode.codeFragment()?.toString?.() : null) || condNode?.name;
                     const body = blk.nodes || [];
@@ -1603,6 +1914,11 @@ class PycDecompiler {
         if (!(node instanceof AST.ASTCondBlock)) {
             return false;
         }
+        // `while True: pass` / `while 1:` has no explicit condition but is a legitimate
+        // user construct; only If blocks are null-sentinel artifacts from with-cleanup.
+        if (node.blockType !== AST.ASTBlock.BlockType.If) {
+            return false;
+        }
         const condition = node.condition;
 
         // Drop degenerate IF blocks with no condition and empty body (often leftover from with cleanup tests)
@@ -1843,25 +2159,72 @@ class PycDecompiler {
             }
 
             const targetName = node.dest?.name || node.dest?.codeFragment?.();
+            const isClassLike = targetName && targetName[0] === targetName[0]?.toUpperCase?.();
+
+            // Preferred path (3.13+): the wrapper's own SourceCode ends with
+            // `return <ASTFunction>` where the function already has correct
+            // annotations (via SET_FUNCTION_ATTRIBUTE) and typeParams with
+            // PEP 696 defaults (via CALL_INTRINSIC_2 intrinsics 5 + 4).
+            const wrapperBody = func.code?.object?.SourceCode?.list || [];
+            let returnedNode = null;
+            for (let j = wrapperBody.length - 1; j >= 0; j--) {
+                const stmt = wrapperBody[j];
+                if (stmt instanceof AST.ASTReturn && stmt.value) {
+                    returnedNode = stmt.value;
+                    break;
+                }
+            }
+            if (!isClassLike && returnedNode instanceof AST.ASTFunction) {
+                node.m_src = returnedNode;
+                continue;
+            }
+            // Classes: the wrapper's direct return is an ASTClass whose base is
+            // an internal CPython temp (".generic_base" for SUBSCRIPT_GENERIC).
+            // Fall through to the Consts-based rebuild which infers clean
+            // typeParams from string names instead.
+
+            // Fallback (pre-3.13 or irregular wrappers): rebuild from Consts.
             const codeConsts = func.code?.object?.Consts?.Value || [];
-            const innerCodeObj = codeConsts.find(c => c?.ClassName === 'Py_CodeObject');
+            const allCodeObjects = codeConsts.filter(c => c?.ClassName === 'Py_CodeObject');
+            let innerCodeObj = allCodeObjects.find(c => c.Name?.toString?.() === targetName);
+            if (!innerCodeObj) {
+                innerCodeObj = allCodeObjects[0];
+            }
             if (!innerCodeObj) {
                 continue;
             }
-            // Extract type parameters: pick uppercase-like strings excluding target name
-            const typeParams = codeConsts
+            const typeParamNames = codeConsts
                 .filter(c => c?.ClassName === 'Py_String')
                 .map(c => c.Value)
                 .filter(v => /^[A-Z][A-Za-z0-9_]*$/.test(v || '') && v !== targetName);
 
-            // Decompile inner code object to get body
+            const typeParams = typeParamNames.map(name => {
+                const defaultCode = allCodeObjects.find(c =>
+                    c !== innerCodeObj &&
+                    (c.ArgCount || 0) === 0 &&
+                    c.Name?.toString?.() === name
+                );
+                if (!defaultCode) return name;
+                try {
+                    const dd = new PycDecompiler(defaultCode);
+                    const body = dd.decompile();
+                    defaultCode.SourceCode = body;
+                    if (dd.errors.length) this.errors.push(...dd.errors);
+                    const list = body?.list || [];
+                    const top = list.top?.() || list[list.length - 1] || list[0];
+                    if (top instanceof AST.ASTReturn && top.value) {
+                        return { name, default: top.value };
+                    }
+                } catch (_) { /* fall through */ }
+                return name;
+            });
+
             const innerDecompiler = new PycDecompiler(innerCodeObj);
             const innerBody = innerDecompiler.decompile();
             innerCodeObj.SourceCode = innerBody;
+            if (innerDecompiler.errors.length) this.errors.push(...innerDecompiler.errors);
             const astObj = new AST.ASTObject(innerCodeObj);
 
-            const isClassLike = targetName && targetName[0] === targetName[0]?.toUpperCase?.();
-
             if (!isClassLike) {
                 const fn = new AST.ASTFunction(astObj);
                 fn.annotations = innerDecompiler.funcAnnotations || fn.annotations;

package/lib/PycDisassembler.js

@@ -17,7 +17,7 @@ class PycDisassembler
                 if (opCode.HasConstant) {
                         argValue = opCode.Constant;
                 } else if (opCode.HasName || opCode.HasLocal || opCode.HasFree) {
-                    argValue = opCode.Name;
+                    argValue = opCode.Name || opCode.LocalName || opCode.FreeName;
                 } else if (opCode.HasJumpRelative) {
                     argValue = opCode.Argument;
                 } else if (opCode.HasCompare) {