diff --git a/Makefile b/Makefile
index 7332c19e0..779719524 100644
--- a/Makefile
+++ b/Makefile
@@ -5,7 +5,7 @@ all: build
 # CI build - optimized for CI/CD environments
 ci: check-java-gradle
 ifeq ($(OS),Windows_NT)
-	gradlew.bat classes testClasses shadowJar --no-daemon --stacktrace
+	gradlew.bat build --no-daemon --stacktrace
 else
 	./gradlew build --no-daemon --stacktrace
 endif
diff --git a/src/main/java/org/perlonjava/app/cli/CompilerOptions.java b/src/main/java/org/perlonjava/app/cli/CompilerOptions.java
index 27a520fcd..78a06a73f 100644
--- a/src/main/java/org/perlonjava/app/cli/CompilerOptions.java
+++ b/src/main/java/org/perlonjava/app/cli/CompilerOptions.java
@@ -49,6 +49,7 @@ public class CompilerOptions implements Cloneable {
     public boolean processAndPrint = false; // For -p
     public boolean inPlaceEdit = false; // New field for in-place editing
     public String code = null;
+    public String deparseSourceCode = null;
     public byte[] rawCodeBytes = null; // Raw file bytes (after BOM removal) for DATA section
     public boolean codeHasEncoding = false;
     public String fileName = null;
diff --git a/src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java b/src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java
index 3f806539f..476a5af68 100644
--- a/src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java
+++ b/src/main/java/org/perlonjava/app/scriptengine/PerlLanguageProvider.java
@@ -154,6 +154,7 @@ public static RuntimeList executePerlCode(CompilerOptions compilerOptions,
         if (compilerOptions.applySourceFilters) {
             compilerOptions.code = FilterUtilCall.preprocessWithBeginFilters(compilerOptions.code);
         }
+        compilerOptions.deparseSourceCode = compilerOptions.code;
 
         // Create the LexerToken list
         Lexer lexer = new Lexer(compilerOptions.code);
@@ -690,6 +691,7 @@ public static Object compilePerlCode(CompilerOptions compilerOptions) throws Exc
         }
 
         // Tokenize
+        compilerOptions.deparseSourceCode = compilerOptions.code;
         Lexer lexer = new Lexer(compilerOptions.code);
         List<LexerToken> tokens = lexer.tokenize();
         compilerOptions.code = null;  // Free memory
@@ -709,4 +711,3 @@ public static Object compilePerlCode(CompilerOptions compilerOptions) throws Exc
         return compileToExecutable(ast, ctx);
     }
 }
-
diff --git a/src/main/java/org/perlonjava/backend/bytecode/BytecodeCompiler.java b/src/main/java/org/perlonjava/backend/bytecode/BytecodeCompiler.java
index 618a503e7..551646cda 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/BytecodeCompiler.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/BytecodeCompiler.java
@@ -6349,9 +6349,11 @@ public void visit(ListNode node) {
             return;
         }
 
-        int elementContext = currentCallContext == RuntimeContextType.LVALUE_LIST
-                ? RuntimeContextType.LVALUE_LIST
-                : RuntimeContextType.LIST;
+        int elementContext = switch (currentCallContext) {
+            case RuntimeContextType.RUNTIME -> RuntimeContextType.RUNTIME;
+            case RuntimeContextType.LVALUE_LIST -> RuntimeContextType.LVALUE_LIST;
+            default -> RuntimeContextType.LIST;
+        };
 
         // Fast path: single element in LIST context
         // In list context, returns a RuntimeList with one element
diff --git a/src/main/java/org/perlonjava/backend/bytecode/CompileBinaryOperator.java b/src/main/java/org/perlonjava/backend/bytecode/CompileBinaryOperator.java
index 97c39efdd..64158dd49 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/CompileBinaryOperator.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/CompileBinaryOperator.java
@@ -253,11 +253,10 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
                     // Allocate result register
                     int rd = bytecodeCompiler.allocateOutputRegister();
 
-                    // Emit CALL_METHOD
-                    // Use emitWithToken so pcToTokenIndex maps the call instruction to the
-                    // invocant's token index (call-site line), not the closing ')' line.
-                    // This ensures caller() inside the called method reports the correct line.
-                    int callSiteToken = node.left.getIndex();
+                    // Emit CALL_METHOD. Perl reports ordinary method calls at
+                    // the expression start, but literal anon sub/block
+                    // arguments report the block/arg line.
+                    int callSiteToken = methodCallerLineCallSiteToken(node, argsNode);
                     if (callSiteToken > 0) {
                         bytecodeCompiler.emitWithToken(Opcodes.CALL_METHOD, callSiteToken);
                     } else {
@@ -418,10 +417,9 @@ else if (node.right instanceof BinaryOperatorNode rightCall) {
             // Check if this is a &func (no parens) call that should share caller's @_
             boolean shareCallerArgs = node.getBooleanAnnotation("shareCallerArgs");
 
-            // Emit CALL_SUB or CALL_SUB_SHARE_ARGS opcode. Ordinary named calls
-            // report the closing line, but non-& prototyped calls report the
-            // expression start; keep the interpreter mapping aligned with the
-            // JVM emitter.
+            // Emit CALL_SUB or CALL_SUB_SHARE_ARGS opcode. Perl reports the
+            // expression start for ordinary multi-line calls, but literal anon
+            // sub/block arguments and &-prototype calls report the block/arg line.
             int callSiteToken = callerLineCallSiteToken(node);
             int rd = CompileBinaryOperatorHelper.compileBinaryOperatorSwitch(
                     bytecodeCompiler, node.operator, rs1, rs2, callSiteToken,
@@ -781,7 +779,7 @@ private static void compileJoinBinaryOp(BytecodeCompiler bytecodeCompiler, Binar
     }
 
     private static int callerLineCallSiteToken(BinaryOperatorNode node) {
-        if (usesExpressionStartLine(node)) {
+        if (!usesBlockArgumentLine(node)) {
             return expressionStartIndex(node);
         }
 
@@ -792,27 +790,47 @@ private static int callerLineCallSiteToken(BinaryOperatorNode node) {
     }
 
     private static int expressionStartIndex(BinaryOperatorNode node) {
-        if (node.getIndex() > 0) {
-            return node.getIndex();
+        if (node.left != null && node.left.getIndex() > 0) {
+            return node.left.getIndex();
         }
+        return node.getIndex() > 0 ? node.getIndex() : -1;
+    }
+
+    private static int methodCallerLineCallSiteToken(BinaryOperatorNode node, Node argsNode) {
+        if (firstArgumentIsLiteralSub(argsNode) && argsNode.getIndex() > 0) {
+            return argsNode.getIndex();
+        }
+
         return node.left != null ? node.left.getIndex() : -1;
     }
 
-    private static boolean usesExpressionStartLine(BinaryOperatorNode node) {
+    private static boolean usesBlockArgumentLine(BinaryOperatorNode node) {
         String prototype = directCallPrototype(node);
-        if (prototype == null) {
+        if (prototype != null) {
+            for (int i = 0; i < prototype.length(); i++) {
+                char c = prototype.charAt(i);
+                if (Character.isWhitespace(c) || c == ';' || c == ',') {
+                    continue;
+                }
+                return c == '&';
+            }
+
             return false;
         }
 
-        for (int i = 0; i < prototype.length(); i++) {
-            char c = prototype.charAt(i);
-            if (Character.isWhitespace(c) || c == ';' || c == ',') {
-                continue;
-            }
-            return c != '&';
+        return firstArgumentIsLiteralSub(node);
+    }
+
+    private static boolean firstArgumentIsLiteralSub(BinaryOperatorNode node) {
+        return firstArgumentIsLiteralSub(node.right);
+    }
+
+    private static boolean firstArgumentIsLiteralSub(Node argsNode) {
+        if (!(argsNode instanceof ListNode list) || list.elements == null || list.elements.isEmpty()) {
+            return false;
         }
 
-        return true;
+        return list.elements.get(0) instanceof SubroutineNode;
     }
 
     private static String directCallPrototype(BinaryOperatorNode node) {
diff --git a/src/main/java/org/perlonjava/backend/bytecode/CompileExistsDelete.java b/src/main/java/org/perlonjava/backend/bytecode/CompileExistsDelete.java
index 3de101524..e0cb7e5a5 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/CompileExistsDelete.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/CompileExistsDelete.java
@@ -131,23 +131,8 @@ private static void visitDeleteHash(BytecodeCompiler bc, OperatorNode node, Bina
     }
 
     private static void visitDeleteHashSlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode hashAccess, OperatorNode leftOp) {
-        int hashReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String hashVarName = "%" + id.name;
-            if (bc.hasVariable(hashVarName)) {
-                hashReg = bc.getVariableRegister(hashVarName);
-            } else {
-                hashReg = bc.allocateRegister();
-                String globalHashName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalHashName);
-                bc.emit(Opcodes.LOAD_GLOBAL_HASH);
-                bc.emitReg(hashReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Hash slice delete requires identifier");
-            return;
-        }
+        int hashReg = resolveHashSliceTarget(bc, node, leftOp, "Hash slice delete requires identifier or reference");
+        if (hashReg < 0) return;
         if (!(hashAccess.right instanceof HashLiteralNode keysNode)) {
             bc.throwCompilerException("Hash slice delete requires HashLiteralNode");
             return;
@@ -162,8 +147,8 @@ private static void visitDeleteHashSlice(BytecodeCompiler bc, OperatorNode node,
                 bc.emit(keyIdx);
                 keyRegs.add(keyReg);
             } else {
-                // Compile key in SCALAR context
-                bc.compileNode(keyElement, -1, RuntimeContextType.SCALAR);
+                // Compile key in LIST context so @array / @$arrayref expand as slice keys.
+                bc.compileNode(keyElement, -1, RuntimeContextType.LIST);
                 keyRegs.add(bc.lastResultReg);
             }
         }
@@ -183,23 +168,8 @@ private static void visitDeleteHashSlice(BytecodeCompiler bc, OperatorNode node,
     }
 
     private static void visitDeleteHashKVSlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode hashAccess, OperatorNode leftOp) {
-        int hashReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String hashVarName = "%" + id.name;
-            if (bc.hasVariable(hashVarName)) {
-                hashReg = bc.getVariableRegister(hashVarName);
-            } else {
-                hashReg = bc.allocateRegister();
-                String globalHashName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalHashName);
-                bc.emit(Opcodes.LOAD_GLOBAL_HASH);
-                bc.emitReg(hashReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Hash kv-slice delete requires identifier");
-            return;
-        }
+        int hashReg = resolveHashSliceTarget(bc, node, leftOp, "Hash kv-slice delete requires identifier or reference");
+        if (hashReg < 0) return;
         if (!(hashAccess.right instanceof HashLiteralNode keysNode)) {
             bc.throwCompilerException("Hash kv-slice delete requires HashLiteralNode");
             return;
@@ -214,8 +184,8 @@ private static void visitDeleteHashKVSlice(BytecodeCompiler bc, OperatorNode nod
                 bc.emit(keyIdx);
                 keyRegs.add(keyReg);
             } else {
-                // Compile key in SCALAR context
-                bc.compileNode(keyElement, -1, RuntimeContextType.SCALAR);
+                // Compile key in LIST context so @array / @$arrayref expand as slice keys.
+                bc.compileNode(keyElement, -1, RuntimeContextType.LIST);
                 keyRegs.add(bc.lastResultReg);
             }
         }
@@ -276,31 +246,16 @@ private static void visitDeleteArray(BytecodeCompiler bc, OperatorNode node, Bin
     }
 
     private static void visitDeleteArraySlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode arrayAccess, OperatorNode leftOp) {
-        int arrayReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String arrayVarName = "@" + id.name;
-            if (bc.hasVariable(arrayVarName)) {
-                arrayReg = bc.getVariableRegister(arrayVarName);
-            } else {
-                arrayReg = bc.allocateRegister();
-                String globalArrayName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalArrayName);
-                bc.emit(Opcodes.LOAD_GLOBAL_ARRAY);
-                bc.emitReg(arrayReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Array slice delete requires identifier");
-            return;
-        }
+        int arrayReg = resolveArraySliceTarget(bc, node, leftOp, "Array slice delete requires identifier or reference");
+        if (arrayReg < 0) return;
         if (!(arrayAccess.right instanceof ArrayLiteralNode indicesNode)) {
             bc.throwCompilerException("Array slice delete requires ArrayLiteralNode");
             return;
         }
         List<Integer> indexRegs = new ArrayList<>();
         for (Node indexElement : indicesNode.elements) {
-            // Compile index in SCALAR context
-            bc.compileNode(indexElement, -1, RuntimeContextType.SCALAR);
+            // Compile index in LIST context so @array / @$arrayref expand as slice indices.
+            bc.compileNode(indexElement, -1, RuntimeContextType.LIST);
             indexRegs.add(bc.lastResultReg);
         }
         int indicesListReg = bc.allocateRegister();
@@ -319,31 +274,16 @@ private static void visitDeleteArraySlice(BytecodeCompiler bc, OperatorNode node
     }
 
     private static void visitDeleteArrayKVSlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode arrayAccess, OperatorNode leftOp) {
-        int arrayReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String arrayVarName = "@" + id.name;
-            if (bc.hasVariable(arrayVarName)) {
-                arrayReg = bc.getVariableRegister(arrayVarName);
-            } else {
-                arrayReg = bc.allocateRegister();
-                String globalArrayName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalArrayName);
-                bc.emit(Opcodes.LOAD_GLOBAL_ARRAY);
-                bc.emitReg(arrayReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Array kv-slice delete requires identifier");
-            return;
-        }
+        int arrayReg = resolveArraySliceTarget(bc, node, leftOp, "Array kv-slice delete requires identifier or reference");
+        if (arrayReg < 0) return;
         if (!(arrayAccess.right instanceof ArrayLiteralNode indicesNode)) {
             bc.throwCompilerException("Array kv-slice delete requires ArrayLiteralNode");
             return;
         }
         List<Integer> indexRegs = new ArrayList<>();
         for (Node indexElement : indicesNode.elements) {
-            // Compile index in SCALAR context
-            bc.compileNode(indexElement, -1, RuntimeContextType.SCALAR);
+            // Compile index in LIST context so @array / @$arrayref expand as slice indices.
+            bc.compileNode(indexElement, -1, RuntimeContextType.LIST);
             indexRegs.add(bc.lastResultReg);
         }
         int indicesListReg = bc.allocateRegister();
@@ -405,6 +345,82 @@ private static void visitDeleteGeneric(BytecodeCompiler bc, Node arg) {
         bc.lastResultReg = rd;
     }
 
+    private static int resolveHashSliceTarget(BytecodeCompiler bc, OperatorNode node, OperatorNode leftOp, String error) {
+        if (leftOp.operand instanceof IdentifierNode id) {
+            return loadHashVariable(bc, id.name, node.getIndex());
+        }
+        if (leftOp.operand instanceof OperatorNode
+                || leftOp.operand instanceof BlockNode
+                || leftOp.operand instanceof BinaryOperatorNode) {
+            bc.compileNode(leftOp.operand, -1, RuntimeContextType.SCALAR);
+            return derefHash(bc, bc.lastResultReg, node.getIndex());
+        }
+        bc.throwCompilerException(error);
+        return -1;
+    }
+
+    private static int resolveArraySliceTarget(BytecodeCompiler bc, OperatorNode node, OperatorNode leftOp, String error) {
+        if (leftOp.operand instanceof IdentifierNode id) {
+            return loadArrayVariable(bc, id.name, node.getIndex());
+        }
+        if (leftOp.operand instanceof OperatorNode
+                || leftOp.operand instanceof BlockNode
+                || leftOp.operand instanceof BinaryOperatorNode) {
+            bc.compileNode(leftOp.operand, -1, RuntimeContextType.SCALAR);
+            return derefArray(bc, bc.lastResultReg, node.getIndex());
+        }
+        bc.throwCompilerException(error);
+        return -1;
+    }
+
+    private static int loadHashVariable(BytecodeCompiler bc, String name, int tokenIndex) {
+        String hashVarName = "%" + name;
+        if (bc.currentSubroutineBeginId != 0 && bc.currentSubroutineClosureVars != null
+                && bc.currentSubroutineClosureVars.contains(hashVarName)) {
+            int hashReg = bc.allocateRegister();
+            int nameIdx = bc.addToStringPool(hashVarName);
+            bc.emitWithToken(Opcodes.RETRIEVE_BEGIN_HASH, tokenIndex);
+            bc.emitReg(hashReg);
+            bc.emit(nameIdx);
+            bc.emit(bc.currentSubroutineBeginId);
+            return hashReg;
+        }
+        if (bc.hasVariable(hashVarName)) {
+            return bc.getVariableRegister(hashVarName);
+        }
+        int hashReg = bc.allocateRegister();
+        String globalHashName = NameNormalizer.normalizeVariableName(name, bc.getCurrentPackage());
+        int nameIdx = bc.addToStringPool(globalHashName);
+        bc.emit(Opcodes.LOAD_GLOBAL_HASH);
+        bc.emitReg(hashReg);
+        bc.emit(nameIdx);
+        return hashReg;
+    }
+
+    private static int loadArrayVariable(BytecodeCompiler bc, String name, int tokenIndex) {
+        String arrayVarName = "@" + name;
+        if (bc.currentSubroutineBeginId != 0 && bc.currentSubroutineClosureVars != null
+                && bc.currentSubroutineClosureVars.contains(arrayVarName)) {
+            int arrayReg = bc.allocateRegister();
+            int nameIdx = bc.addToStringPool(arrayVarName);
+            bc.emitWithToken(Opcodes.RETRIEVE_BEGIN_ARRAY, tokenIndex);
+            bc.emitReg(arrayReg);
+            bc.emit(nameIdx);
+            bc.emit(bc.currentSubroutineBeginId);
+            return arrayReg;
+        }
+        if (bc.hasVariable(arrayVarName)) {
+            return bc.getVariableRegister(arrayVarName);
+        }
+        int arrayReg = bc.allocateRegister();
+        String globalArrayName = NameNormalizer.normalizeVariableName(name, bc.getCurrentPackage());
+        int nameIdx = bc.addToStringPool(globalArrayName);
+        bc.emit(Opcodes.LOAD_GLOBAL_ARRAY);
+        bc.emitReg(arrayReg);
+        bc.emit(nameIdx);
+        return arrayReg;
+    }
+
     private static int resolveHashFromBinaryOp(BytecodeCompiler bc, BinaryOperatorNode hashAccess, int tokenIndex) {
         if (hashAccess.left instanceof OperatorNode leftOp) {
             if (leftOp.operator.equals("$") && leftOp.operand instanceof IdentifierNode id) {
@@ -567,23 +583,8 @@ private static void visitDeleteLocalHash(BytecodeCompiler bc, OperatorNode node,
     }
 
     private static void visitDeleteLocalHashSlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode hashAccess, OperatorNode leftOp) {
-        int hashReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String hashVarName = "%" + id.name;
-            if (bc.hasVariable(hashVarName)) {
-                hashReg = bc.getVariableRegister(hashVarName);
-            } else {
-                hashReg = bc.allocateRegister();
-                String globalHashName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalHashName);
-                bc.emit(Opcodes.LOAD_GLOBAL_HASH);
-                bc.emitReg(hashReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Hash slice delete local requires identifier");
-            return;
-        }
+        int hashReg = resolveHashSliceTarget(bc, node, leftOp, "Hash slice delete local requires identifier or reference");
+        if (hashReg < 0) return;
         if (!(hashAccess.right instanceof HashLiteralNode keysNode)) {
             bc.throwCompilerException("Hash slice delete local requires HashLiteralNode");
             return;
@@ -598,7 +599,7 @@ private static void visitDeleteLocalHashSlice(BytecodeCompiler bc, OperatorNode
                 bc.emit(keyIdx);
                 keyRegs.add(keyReg);
             } else {
-                bc.compileNode(keyElement, -1, RuntimeContextType.SCALAR);
+                bc.compileNode(keyElement, -1, RuntimeContextType.LIST);
                 keyRegs.add(bc.lastResultReg);
             }
         }
@@ -633,30 +634,15 @@ private static void visitDeleteLocalArray(BytecodeCompiler bc, OperatorNode node
     }
 
     private static void visitDeleteLocalArraySlice(BytecodeCompiler bc, OperatorNode node, BinaryOperatorNode arrayAccess, OperatorNode leftOp) {
-        int arrayReg;
-        if (leftOp.operand instanceof IdentifierNode id) {
-            String arrayVarName = "@" + id.name;
-            if (bc.hasVariable(arrayVarName)) {
-                arrayReg = bc.getVariableRegister(arrayVarName);
-            } else {
-                arrayReg = bc.allocateRegister();
-                String globalArrayName = NameNormalizer.normalizeVariableName(id.name, bc.getCurrentPackage());
-                int nameIdx = bc.addToStringPool(globalArrayName);
-                bc.emit(Opcodes.LOAD_GLOBAL_ARRAY);
-                bc.emitReg(arrayReg);
-                bc.emit(nameIdx);
-            }
-        } else {
-            bc.throwCompilerException("Array slice delete local requires identifier");
-            return;
-        }
+        int arrayReg = resolveArraySliceTarget(bc, node, leftOp, "Array slice delete local requires identifier or reference");
+        if (arrayReg < 0) return;
         if (!(arrayAccess.right instanceof ArrayLiteralNode indicesNode)) {
             bc.throwCompilerException("Array slice delete local requires ArrayLiteralNode");
             return;
         }
         List<Integer> indexRegs = new ArrayList<>();
         for (Node indexElement : indicesNode.elements) {
-            bc.compileNode(indexElement, -1, RuntimeContextType.SCALAR);
+            bc.compileNode(indexElement, -1, RuntimeContextType.LIST);
             indexRegs.add(bc.lastResultReg);
         }
         int indicesListReg = bc.allocateRegister();
diff --git a/src/main/java/org/perlonjava/backend/bytecode/CompileOperator.java b/src/main/java/org/perlonjava/backend/bytecode/CompileOperator.java
index a0c079d31..180543137 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/CompileOperator.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/CompileOperator.java
@@ -992,12 +992,19 @@ public static void visitOperator(BytecodeCompiler bytecodeCompiler, OperatorNode
                 // The regular RETURN opcode is used for implicit end-of-block returns.
                 short returnOpcode = bytecodeCompiler.isInMapGrepBlock
                         ? Opcodes.RETURN_NONLOCAL : Opcodes.RETURN;
-                if (node.operand != null) {
-                    node.operand.accept(bytecodeCompiler);
+                boolean hasOperand = !(node.operand == null
+                        || (node.operand instanceof ListNode list && list.elements.isEmpty()));
+                if (!hasOperand) {
+                    int listReg = bytecodeCompiler.allocateRegister();
+                    bytecodeCompiler.emit(Opcodes.CREATE_LIST);
+                    bytecodeCompiler.emitReg(listReg);
+                    bytecodeCompiler.emit(0);
+                    bytecodeCompiler.lastResultReg = listReg;
+                } else if (node.operand instanceof ListNode list && list.elements.size() == 1) {
+                    bytecodeCompiler.compileNode(
+                            list.elements.getFirst(), -1, RuntimeContextType.RUNTIME);
                 } else {
-                    int undefReg = bytecodeCompiler.allocateRegister();
-                    bytecodeCompiler.emit(Opcodes.LOAD_UNDEF);
-                    bytecodeCompiler.emitReg(undefReg);
+                    bytecodeCompiler.compileNode(node.operand, -1, RuntimeContextType.RUNTIME);
                 }
                 int exprReg = bytecodeCompiler.lastResultReg;
 
diff --git a/src/main/java/org/perlonjava/backend/bytecode/EvalStringHandler.java b/src/main/java/org/perlonjava/backend/bytecode/EvalStringHandler.java
index 07a0753df..8038a6755 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/EvalStringHandler.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/EvalStringHandler.java
@@ -38,6 +38,43 @@ private static void evalTrace(String msg) {
         }
     }
 
+    private static final class EvalSeedAlias {
+        final char sigil;
+        final String fullName;
+        final RuntimeBase value;
+
+        EvalSeedAlias(char sigil, String fullName, RuntimeBase value) {
+            this.sigil = sigil;
+            this.fullName = fullName;
+            this.value = value;
+        }
+    }
+
+    private static void deactivateEvalSeedAliases(List<EvalSeedAlias> aliases) {
+        for (EvalSeedAlias alias : aliases) {
+            switch (alias.sigil) {
+                case '$' -> {
+                    if (GlobalVariable.globalVariables.get(alias.fullName) == alias.value) {
+                        GlobalVariable.globalVariables.remove(alias.fullName);
+                    }
+                }
+                case '@' -> {
+                    if (GlobalVariable.globalArrays.get(alias.fullName) == alias.value) {
+                        GlobalVariable.globalArrays.remove(alias.fullName);
+                    }
+                }
+                case '%' -> {
+                    if (GlobalVariable.globalHashes.get(alias.fullName) == alias.value) {
+                        GlobalVariable.globalHashes.remove(alias.fullName);
+                    }
+                }
+                default -> {
+                }
+            }
+        }
+        aliases.clear();
+    }
+
     /**
      * Evaluate a Perl string dynamically.
      * <p>
@@ -160,6 +197,7 @@ private static RuntimeList evalStringList(String perlCode,
                                              int siteStrictOptions,
                                              int siteFeatureFlags,
                                              boolean isEvalbytes) {
+        List<EvalSeedAlias> seedAliases = new ArrayList<>();
         try {
             evalTrace("EvalStringHandler enter ctx=" + callContext + " srcName=" + sourceName +
                     " srcLine=" + sourceLine + " codeLen=" + (perlCode != null ? perlCode.length() : -1) +
@@ -275,11 +313,17 @@ private static RuntimeList evalStringList(String perlCode,
                     String bareName = varName.substring(1);
                     String fullName = seedPkg + "::" + bareName;
                     if (sigil == '$' && value instanceof RuntimeScalar rs) {
-                        GlobalVariable.globalVariables.put(fullName, rs);
+                        if (GlobalVariable.globalVariables.putIfAbsent(fullName, rs) == null) {
+                            seedAliases.add(new EvalSeedAlias(sigil, fullName, rs));
+                        }
                     } else if (sigil == '@' && value instanceof RuntimeArray ra) {
-                        GlobalVariable.globalArrays.put(fullName, ra);
+                        if (GlobalVariable.globalArrays.putIfAbsent(fullName, ra) == null) {
+                            seedAliases.add(new EvalSeedAlias(sigil, fullName, ra));
+                        }
                     } else if (sigil == '%' && value instanceof RuntimeHash rh) {
-                        GlobalVariable.globalHashes.put(fullName, rh);
+                        if (GlobalVariable.globalHashes.putIfAbsent(fullName, rh) == null) {
+                            seedAliases.add(new EvalSeedAlias(sigil, fullName, rh));
+                        }
                     } else {
                         // Sigil / value-type mismatch (e.g. captured as null).
                         // Skip the alias but still proceed to the symbol-table
@@ -396,6 +440,11 @@ private static RuntimeList evalStringList(String perlCode,
                 evalCode = evalCode.withCapturedVars(currentCode.capturedVars);
             }
 
+            // These aliases are parser/compile-time helpers only. Direct eval
+            // body references use captured registers, and named subs have
+            // already captured the aliased cells by this point.
+            deactivateEvalSeedAliases(seedAliases);
+
             // Step 6: Execute the compiled code.
             // IMPORTANT: Scope InterpreterState.currentPackage around eval execution.
             // currentPackage is a runtime-only field used by caller() — it does NOT
@@ -426,6 +475,8 @@ private static RuntimeList evalStringList(String perlCode,
             evalTrace("EvalStringHandler exec exception ctx=" + callContext + " ex=" + e.getClass().getSimpleName() + " msg=" + e.getMessage());
             WarnDie.catchEval(e);
             return new RuntimeList(new RuntimeScalar());
+        } finally {
+            deactivateEvalSeedAliases(seedAliases);
         }
     }
 
diff --git a/src/main/java/org/perlonjava/backend/bytecode/InterpretedCode.java b/src/main/java/org/perlonjava/backend/bytecode/InterpretedCode.java
index ae5d3633e..940d1c79a 100644
--- a/src/main/java/org/perlonjava/backend/bytecode/InterpretedCode.java
+++ b/src/main/java/org/perlonjava/backend/bytecode/InterpretedCode.java
@@ -1,6 +1,7 @@
 package org.perlonjava.backend.bytecode;
 
 import org.perlonjava.runtime.WarningBitsRegistry;
+import org.perlonjava.runtime.perlmodule.Strict;
 import org.perlonjava.runtime.runtimetypes.*;
 
 import java.util.BitSet;
@@ -23,6 +24,8 @@
  * - InterpretedCode overrides apply() to dispatch to BytecodeInterpreter
  */
 public class InterpretedCode extends RuntimeCode implements PerlSubroutine {
+    private static final int DEPARSE_SOURCE_TEXT_LIMIT = 64 * 1024;
+
     // Bytecode and metadata
     public final int[] bytecode;           // Instruction stream (opcodes + operands as ints)
     public final Object[] constants;       // Constant pool (RuntimeBase objects)
@@ -194,6 +197,16 @@ public InterpretedCode(int[] bytecode, Object[] constants, String[] stringPool,
         }
         this.cvStartFile = sourceName;
         this.cvStartLine = sourceLine;
+        this.deparseSourceText = shouldKeepRuntimeDeparseSource(sourceName)
+                ? sourceTextFromErrorUtil(errorUtil)
+                : null;
+        int strictAll = Strict.HINT_STRICT_REFS | Strict.HINT_STRICT_SUBS | Strict.HINT_STRICT_VARS;
+        if ((strictOptions & strictAll) == strictAll) {
+            this.deparseFlags |= RuntimeCode.DEPARSE_FLAG_STRICT;
+        }
+        if (warningFlags != null && !warningFlags.isEmpty()) {
+            this.deparseFlags |= RuntimeCode.DEPARSE_FLAG_WARNINGS;
+        }
         // Scan bytecodes to find registers used by SCOPE_EXIT_CLEANUP opcodes.
         // These are the actual "my" variable registers that need cleanup during
         // exception propagation. Temporaries (hash element aliases, method return
@@ -206,6 +219,37 @@ public InterpretedCode(int[] bytecode, Object[] constants, String[] stringPool,
         }
     }
 
+    private static String sourceTextFromErrorUtil(ErrorMessageUtil errorUtil) {
+        if (errorUtil == null) {
+            return null;
+        }
+        String[] lines = errorUtil.extractSourceLines();
+        if (lines == null || lines.length <= 1) {
+            return null;
+        }
+        StringBuilder source = new StringBuilder();
+        for (int i = 1; i < lines.length; i++) {
+            if (i > 1) {
+                source.append('\n');
+            }
+            source.append(lines[i]);
+            if (source.length() > DEPARSE_SOURCE_TEXT_LIMIT) {
+                return null;
+            }
+        }
+        return source.toString();
+    }
+
+    private static boolean shouldKeepRuntimeDeparseSource(String sourceName) {
+        if (sourceName == null || sourceName.isEmpty()) {
+            return true;
+        }
+        if ("-e".equals(sourceName)) {
+            return true;
+        }
+        return !new java.io.File(sourceName).isFile();
+    }
+
     // Legacy constructor for backward compatibility
     public InterpretedCode(int[] bytecode, Object[] constants, String[] stringPool,
                            int maxRegisters, RuntimeBase[] capturedVars,
diff --git a/src/main/java/org/perlonjava/backend/jvm/Dereference.java b/src/main/java/org/perlonjava/backend/jvm/Dereference.java
index dd6755f8f..afa92bc0d 100644
--- a/src/main/java/org/perlonjava/backend/jvm/Dereference.java
+++ b/src/main/java/org/perlonjava/backend/jvm/Dereference.java
@@ -971,18 +971,18 @@ static void handleArrowOperator(EmitterVisitor emitterVisitor, BinaryOperatorNod
 
             // Allocate a unique callsite ID for inline method caching
             int callsiteId = nextMethodCallsiteId++;
-            // Set debug line number to the whole method call. Perl's caller()
-            // reports the closing line for a multi-line call expression, which
-            // is carried by the "->" node or its argument ListNode.
-            int callSiteIndex = node.getIndex();
+            // Perl reports the method expression start for ordinary multi-line
+            // calls, but literal anon sub/block arguments report the block line.
+            int callSiteIndex = node.left.getIndex();
             if (node.right instanceof BinaryOperatorNode callNode
                     && "(".equals(callNode.operator)
+                    && firstMethodArgumentIsLiteralSub(callNode)
                     && callNode.right != null
                     && callNode.right.getIndex() > 0) {
                 callSiteIndex = callNode.right.getIndex();
             }
-            if (callSiteIndex <= 0 && node.left.getIndex() > 0) {
-                callSiteIndex = node.left.getIndex();
+            if (callSiteIndex <= 0 && node.getIndex() > 0) {
+                callSiteIndex = node.getIndex();
             }
             if (callSiteIndex > 0) {
                 ByteCodeSourceMapper.setDebugInfoLineNumber(emitterVisitor.ctx, callSiteIndex);
@@ -1153,6 +1153,14 @@ static void handleArrowOperator(EmitterVisitor emitterVisitor, BinaryOperatorNod
         }
     }
 
+    private static boolean firstMethodArgumentIsLiteralSub(BinaryOperatorNode callNode) {
+        if (!(callNode.right instanceof ListNode list) || list.elements == null || list.elements.isEmpty()) {
+            return false;
+        }
+
+        return list.elements.get(0) instanceof SubroutineNode;
+    }
+
     public static void handleArrowArrayDeref(EmitterVisitor emitterVisitor, BinaryOperatorNode node, String arrayOperation) {
         if (CompilerOptions.DEBUG_ENABLED) emitterVisitor.ctx.logDebug("visit(BinaryOperatorNode) ->[] ");
         EmitterVisitor scalarVisitor =
diff --git a/src/main/java/org/perlonjava/backend/jvm/EmitSubroutine.java b/src/main/java/org/perlonjava/backend/jvm/EmitSubroutine.java
index c03e79f00..867bf0f80 100644
--- a/src/main/java/org/perlonjava/backend/jvm/EmitSubroutine.java
+++ b/src/main/java/org/perlonjava/backend/jvm/EmitSubroutine.java
@@ -25,6 +25,8 @@
 import java.util.TreeMap;
 
 import static org.perlonjava.runtime.perlmodule.Strict.HINT_STRICT_REFS;
+import static org.perlonjava.runtime.perlmodule.Strict.HINT_STRICT_SUBS;
+import static org.perlonjava.runtime.perlmodule.Strict.HINT_STRICT_VARS;
 
 /**
  * The EmitSubroutine class is responsible for handling subroutine-related operations
@@ -252,6 +254,26 @@ public static void emitSubroutine(EmitterContext ctx, SubroutineNode node) {
             } else if (ctx.compilerOptions != null && ctx.compilerOptions.fileName != null) {
                 cvStartFile = ctx.compilerOptions.fileName;
             }
+            int deparseSourceOffset = -1;
+            if (ctx.errorUtil != null && node.block != null) {
+                deparseSourceOffset = ctx.errorUtil.getSourceOffset(node.block.getIndex());
+            }
+            String deparseSourceText = null;
+            if (ctx.compilerOptions != null) {
+                deparseSourceText = ctx.compilerOptions.deparseSourceCode != null
+                        ? ctx.compilerOptions.deparseSourceCode
+                        : ctx.compilerOptions.code;
+            }
+            int deparseFlags = 0;
+            int strictAll = HINT_STRICT_REFS | HINT_STRICT_SUBS | HINT_STRICT_VARS;
+            if ((ctx.symbolTable.getStrictOptions() & strictAll) == strictAll) {
+                deparseFlags |= RuntimeCode.DEPARSE_FLAG_STRICT;
+            }
+            if (ctx.symbolTable.warningFlagsStack != null
+                    && !ctx.symbolTable.warningFlagsStack.isEmpty()
+                    && !ctx.symbolTable.warningFlagsStack.peek().isEmpty()) {
+                deparseFlags |= RuntimeCode.DEPARSE_FLAG_WARNINGS;
+            }
 
             // Transfer pad constants (cached string literals referenced via \) from compile time
             // to a registry so makeCodeObject() can attach them to the RuntimeCode at runtime.
@@ -303,11 +325,18 @@ public static void emitSubroutine(EmitterContext ctx, SubroutineNode node) {
             mv.visitLdcInsn(ctx.symbolTable.getCurrentPackage());
             mv.visitLdcInsn(cvStartFile);
             mv.visitLdcInsn(cvStartLine);
+            if (deparseSourceText != null) {
+                mv.visitLdcInsn(deparseSourceText);
+            } else {
+                mv.visitInsn(Opcodes.ACONST_NULL);
+            }
+            mv.visitLdcInsn(deparseFlags);
+            mv.visitLdcInsn(deparseSourceOffset);
             mv.visitMethodInsn(
                     Opcodes.INVOKESTATIC,
                     "org/perlonjava/runtime/runtimetypes/RuntimeCode",
                     "makeCodeObject",
-                    "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;I)Lorg/perlonjava/runtime/runtimetypes/RuntimeScalar;",
+                    "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;II)Lorg/perlonjava/runtime/runtimetypes/RuntimeScalar;",
                     false);
         } catch (InterpreterFallbackException fallback) {
             // JVM compilation failed (e.g., ASM frame crash) - use InterpretedCode instead
@@ -783,9 +812,9 @@ static void handleApplyOperator(EmitterVisitor emitterVisitor, BinaryOperatorNod
                 "(Lorg/perlonjava/runtime/runtimetypes/RuntimeScalar;Ljava/lang/String;)V",
                 false);
 
-        // Set debug line number to the call site. Ordinary direct calls report
-        // the completed call expression's closing line, but prototyped calls
-        // whose first prototype slot is not `&` report the expression start.
+        // Set debug line number to the call site. Perl reports the expression
+        // start for ordinary multi-line calls, but literal anon sub/block
+        // arguments and &-prototype calls report the block/arg line.
         int callSiteIndex = callerLineCallSiteIndex(node);
         if (callSiteIndex > 0) {
             ByteCodeSourceMapper.setDebugInfoLineNumber(emitterVisitor.ctx, callSiteIndex);
@@ -911,7 +940,7 @@ static void handleApplyOperator(EmitterVisitor emitterVisitor, BinaryOperatorNod
     }
 
     private static int callerLineCallSiteIndex(BinaryOperatorNode node) {
-        if (usesExpressionStartLine(node)) {
+        if (!usesBlockArgumentLine(node)) {
             return expressionStartIndex(node);
         }
 
@@ -922,27 +951,35 @@ private static int callerLineCallSiteIndex(BinaryOperatorNode node) {
     }
 
     private static int expressionStartIndex(BinaryOperatorNode node) {
-        if (node.getIndex() > 0) {
-            return node.getIndex();
+        if (node.left != null && node.left.getIndex() > 0) {
+            return node.left.getIndex();
         }
-        return node.left != null ? node.left.getIndex() : -1;
+        return node.getIndex() > 0 ? node.getIndex() : -1;
     }
 
-    private static boolean usesExpressionStartLine(BinaryOperatorNode node) {
+    private static boolean usesBlockArgumentLine(BinaryOperatorNode node) {
         String prototype = directCallPrototype(node);
-        if (prototype == null) {
+        if (prototype != null) {
+            for (int i = 0; i < prototype.length(); i++) {
+                char c = prototype.charAt(i);
+                if (Character.isWhitespace(c) || c == ';' || c == ',') {
+                    continue;
+                }
+                return c == '&';
+            }
+
             return false;
         }
 
-        for (int i = 0; i < prototype.length(); i++) {
-            char c = prototype.charAt(i);
-            if (Character.isWhitespace(c) || c == ';' || c == ',') {
-                continue;
-            }
-            return c != '&';
+        return firstArgumentIsLiteralSub(node);
+    }
+
+    private static boolean firstArgumentIsLiteralSub(BinaryOperatorNode node) {
+        if (!(node.right instanceof ListNode list) || list.elements == null || list.elements.isEmpty()) {
+            return false;
         }
 
-        return true;
+        return list.elements.get(0) instanceof SubroutineNode;
     }
 
     private static String directCallPrototype(BinaryOperatorNode node) {
diff --git a/src/main/java/org/perlonjava/frontend/parser/Variable.java b/src/main/java/org/perlonjava/frontend/parser/Variable.java
index 146f9b273..13412341f 100644
--- a/src/main/java/org/perlonjava/frontend/parser/Variable.java
+++ b/src/main/java/org/perlonjava/frontend/parser/Variable.java
@@ -784,6 +784,7 @@ static Node parseCoderefVariable(Parser parser, LexerToken token) {
         Node node = parseVariable(parser, token.text);
         // Reset the flag after parsing
         parser.parsingForLoopVariable = false;
+        annotateParseTimeCodeRef(parser, node);
 
         // If we are parsing a reference (e.g., \&sub or defined(&sub)),
         // return the node without adding parameters.
@@ -845,6 +846,21 @@ static Node parseCoderefVariable(Parser parser, LexerToken token) {
         return callNode;
     }
 
+    private static void annotateParseTimeCodeRef(Parser parser, Node node) {
+        if (!(node instanceof OperatorNode operatorNode)
+                || !operatorNode.operator.equals("&")
+                || !(operatorNode.operand instanceof IdentifierNode identifierNode)) {
+            return;
+        }
+
+        String fullName = NameNormalizer.normalizeVariableName(
+                identifierNode.name,
+                parser.ctx.symbolTable.getCurrentPackage());
+        if (GlobalVariable.isGlobalCodeRefDefined(fullName)) {
+            operatorNode.setAnnotation("parseTimeCodeRef", GlobalVariable.getGlobalCodeRef(fullName));
+        }
+    }
+
     /**
      * Parses a braced variable expression like {@code ${var}} or {@code ${expr}}.
      *
diff --git a/src/main/java/org/perlonjava/runtime/operators/ReferenceOperators.java b/src/main/java/org/perlonjava/runtime/operators/ReferenceOperators.java
index 313838a2f..293d8da89 100644
--- a/src/main/java/org/perlonjava/runtime/operators/ReferenceOperators.java
+++ b/src/main/java/org/perlonjava/runtime/operators/ReferenceOperators.java
@@ -177,6 +177,7 @@ public static RuntimeScalar bless(RuntimeScalar runtimeScalar, RuntimeScalar cla
                 // Activate the mortal mechanism
                 MortalList.active = true;
             }
+            DestroyDispatch.registerIfDestroyable(referent, newBlessId);
         } else {
             throw new PerlCompilerException("Can't bless non-reference value");
         }
diff --git a/src/main/java/org/perlonjava/runtime/operators/SystemOperator.java b/src/main/java/org/perlonjava/runtime/operators/SystemOperator.java
index 9204f1d61..49892b4cf 100644
--- a/src/main/java/org/perlonjava/runtime/operators/SystemOperator.java
+++ b/src/main/java/org/perlonjava/runtime/operators/SystemOperator.java
@@ -33,8 +33,8 @@
  */
 public class SystemOperator {
 
-    // Pattern to detect shell metacharacters
-    private static final Pattern SHELL_METACHARACTERS = Pattern.compile("[*?\\[\\]{}()<>|&;`'\"\\\\$\\s]");
+    // Shell syntax that prevents Perl's one-string command direct-exec fast path.
+    private static final Pattern DIRECT_COMMAND_SHELL_METACHARACTERS = Pattern.compile("[*?\\[\\]{}()<>|&;`'\"\\$%]");
 
     /**
      * Executes a system command and returns the output as a RuntimeBase.
@@ -70,15 +70,11 @@ public static RuntimeBase systemCommand(RuntimeScalar command, int ctx) {
         String cmd = command.toString();
         CommandResult result;
 
-        // Check for shell metacharacters - if none, execute directly without shell
-        // This matches native Perl behavior where simple commands bypass the shell
-        if (SHELL_METACHARACTERS.matcher(cmd).find()) {
-            // Has shell metacharacters, use shell
-            result = executeCommand(cmd, true);
+        List<String> directCommand = splitDirectCommandWords(cmd);
+        if (directCommand != null) {
+            result = executeCommandDirectCapture(directCommand);
         } else {
-            // No shell metacharacters, split into words and execute directly
-            String[] words = cmd.trim().split("\\s+");
-            result = executeCommandDirectCapture(Arrays.asList(words));
+            result = executeCommand(cmd, true);
         }
 
         // Set $? to the exit status
@@ -130,13 +126,11 @@ public static RuntimeScalar system(RuntimeList args, boolean hasHandle, int ctx)
         } else if (!hasHandle && flattenedArgs.size() == 1) {
             // Single argument - check for shell metacharacters
             String command = flattenedArgs.getFirst();
-            if (SHELL_METACHARACTERS.matcher(command).find()) {
-                // Has shell metacharacters, use shell
-                result = executeCommand(command, false);
+            List<String> directCommand = splitDirectCommandWords(command);
+            if (directCommand != null) {
+                result = executeCommandDirect(directCommand);
             } else {
-                // No shell metacharacters, split into words and execute directly
-                String[] words = command.trim().split("\\s+");
-                result = executeCommandDirect(Arrays.asList(words));
+                result = executeCommand(command, false);
             }
         } else {
             // Multiple arguments - execute directly without shell
@@ -184,6 +178,23 @@ private static List<String> flattenToStringList(List<RuntimeBase> elements) {
         return result;
     }
 
+    private static List<String> splitDirectCommandWords(String command) {
+        String trimmed = command.trim();
+        if (trimmed.isEmpty()) {
+            return null;
+        }
+
+        if (DIRECT_COMMAND_SHELL_METACHARACTERS.matcher(trimmed).find()) {
+            return null;
+        }
+
+        if (!SystemUtils.osIsWindows() && trimmed.contains("\\")) {
+            return null;
+        }
+
+        return Arrays.asList(trimmed.split("\\s+"));
+    }
+
     /**
      * Java's ProcessBuilder does not reliably perform execvp-style PATH lookup
      * for argv-list commands. Perl's system LIST, exec LIST, and simple qx// do.
@@ -866,13 +877,11 @@ public static RuntimeScalar exec(RuntimeList args, boolean hasHandle, int ctx) {
             } else if (!hasHandle && flattenedArgs.size() == 1) {
                 // Single argument - check for shell metacharacters
                 String command = flattenedArgs.getFirst();
-                if (SHELL_METACHARACTERS.matcher(command).find()) {
-                    // Has shell metacharacters, use shell
-                    exitCode = execCommand(command);
+                List<String> directCommand = splitDirectCommandWords(command);
+                if (directCommand != null) {
+                    exitCode = execCommandDirect(directCommand);
                 } else {
-                    // No shell metacharacters, split into words and execute directly
-                    String[] words = command.trim().split("\\s+");
-                    exitCode = execCommandDirect(Arrays.asList(words));
+                    exitCode = execCommand(command);
                 }
             } else {
                 // Multiple arguments - execute directly without shell
@@ -927,16 +936,15 @@ private static RuntimeScalar completeForkOpen(List<String> flattenedArgs, boolea
                 command.addAll(flattenedArgs.subList(2, flattenedArgs.size()));
             } else if (!hasHandle && flattenedArgs.size() == 1) {
                 String cmdStr = flattenedArgs.getFirst();
-                if (SHELL_METACHARACTERS.matcher(cmdStr).find()) {
-                    // Use shell for metacharacters
+                List<String> directCommand = splitDirectCommandWords(cmdStr);
+                if (directCommand != null) {
+                    command = directCommand;
+                } else {
                     if (SystemUtils.osIsWindows()) {
                         command = Arrays.asList("cmd.exe", "/c", cmdStr);
                     } else {
                         command = Arrays.asList("/bin/sh", "-c", cmdStr);
                     }
-                } else {
-                    // Split simple command
-                    command = Arrays.asList(cmdStr.trim().split("\\s+"));
                 }
             } else {
                 command = flattenedArgs;
diff --git a/src/main/java/org/perlonjava/runtime/perlmodule/Internals.java b/src/main/java/org/perlonjava/runtime/perlmodule/Internals.java
index 5c113b57d..5c989e668 100644
--- a/src/main/java/org/perlonjava/runtime/perlmodule/Internals.java
+++ b/src/main/java/org/perlonjava/runtime/perlmodule/Internals.java
@@ -40,6 +40,9 @@ public static void initialize() {
             // objects) and clears weak refs for unreachable objects. Returns
             // the number of weak refs cleared.
             internals.registerMethod("jperl_gc", "jperl_gc", "");
+            internals.registerMethod("jperl_gc_quiet", "jperl_gc_quiet", "");
+            internals.registerMethod("jperl_sweep_destroyables_no_jvm_gc", "jperl_sweep_destroyables_no_jvm_gc", "");
+            internals.registerMethod("jperl_freetmps", "jperl_freetmps", "");
             // Phase 4 diagnostic: trace a reachable path from any Perl root
             // to the given referent. Returns the first-found path string or
             // undef if unreachable. Used to debug why an object that should
@@ -60,6 +63,7 @@ public static void initialize() {
             // such as Pod::Coverage can skip imported helpers.
             internals.registerMethod("jperl_is_imported_sub", "jperl_is_imported_sub", "$");
             internals.registerMethod("jperl_cv_start_location", "jperlCvStartLocation", "$");
+            internals.registerMethod("jperl_cv_deparse_info", "jperlCvDeparseInfo", "$");
             internals.registerMethod("jperl_cv_is_constant", "jperlCvIsConstant", "$");
             internals.registerMethod("jperl_end_av_ref", "jperlEndAvRef", "");
         } catch (NoSuchMethodException e) {
@@ -261,6 +265,39 @@ public static RuntimeList jperl_gc(RuntimeArray args, int ctx) {
         return new RuntimeScalar(cleared + secondPass).getList();
     }
 
+    /**
+     * Quiet statement-boundary sweep. Unlike jperl_gc(), this does not drain
+     * rescued DBIC-style objects before END-time cleanup.
+     */
+    public static RuntimeList jperl_gc_quiet(RuntimeArray args, int ctx) {
+        int cleared = ReachabilityWalker.sweepWeakRefs(true);
+        int secondPass = ReachabilityWalker.sweepWeakRefs(true);
+        return new RuntimeScalar(cleared + secondPass).getList();
+    }
+
+    /**
+     * Drain Perl-style mortal temporaries without asking the JVM to run GC.
+     * This mirrors Perl's FREETMPS boundary for refcounted RuntimeBase objects.
+     */
+    public static RuntimeList jperl_freetmps(RuntimeArray args, int ctx) {
+        MortalList.flush();
+        return new RuntimeScalar(0).getList();
+    }
+
+    /**
+     * Reconcile destroyable objects that require deterministic DESTROY side
+     * effects but are not weak-ref referents, without clearing arbitrary weak
+     * refs and without forcing HotSpot GC. Used by DBI statement polling to
+     * match Perl's cursor DESTROY/finish timing.
+     */
+    public static RuntimeList jperl_sweep_destroyables_no_jvm_gc(RuntimeArray args, int ctx) {
+        int destroyed = ReachabilityWalker.sweepDestroyableObjects(false);
+        if (destroyed > 0) {
+            destroyed += ReachabilityWalker.sweepDestroyableObjects(false);
+        }
+        return new RuntimeScalar(destroyed).getList();
+    }
+
     /**
      * Phase 4 diagnostic: find a reachable path from Perl roots to the
      * given referent. Returns the path as a string ("$some::global{key}[3]")
@@ -665,6 +702,24 @@ public static RuntimeList jperlCvStartLocation(RuntimeArray args, int ctx) {
         return new RuntimeList(new RuntimeScalar(file), new RuntimeScalar(line));
     }
 
+    public static RuntimeList jperlCvDeparseInfo(RuntimeArray args, int ctx) {
+        if (args.size() == 0) {
+            return new RuntimeList(new RuntimeScalar(), new RuntimeScalar(0));
+        }
+        RuntimeScalar s = args.get(0);
+        if (s == null) {
+            return new RuntimeList(new RuntimeScalar(), new RuntimeScalar(0));
+        }
+        s = s.scalar();
+        if (s.type != RuntimeScalarType.CODE || !(s.value instanceof RuntimeCode code)) {
+            return new RuntimeList(new RuntimeScalar(), new RuntimeScalar(0));
+        }
+        RuntimeScalar source = code.deparseSourceText != null
+                ? new RuntimeScalar(code.deparseSourceText)
+                : new RuntimeScalar();
+        return new RuntimeList(source, new RuntimeScalar(code.deparseFlags), new RuntimeScalar(code.deparseSourceOffset));
+    }
+
     /**
      * Returns true when a CODE reference represents a compile-time constant CV.
      * Used by the bundled {@code B} shim for {@code B::CV->CvFLAGS}.
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/DestroyDispatch.java b/src/main/java/org/perlonjava/runtime/runtimetypes/DestroyDispatch.java
index e9ed3fa97..2c916d599 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/DestroyDispatch.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/DestroyDispatch.java
@@ -3,7 +3,11 @@
 import org.perlonjava.runtime.mro.InheritanceResolver;
 import org.perlonjava.runtime.operators.WarnDie;
 
+import java.util.ArrayList;
 import java.util.BitSet;
+import java.util.Collections;
+import java.util.IdentityHashMap;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 /**
@@ -24,6 +28,13 @@ public class DestroyDispatch {
     private static final ConcurrentHashMap<Integer, RuntimeScalar> destroyMethodCache =
             new ConcurrentHashMap<>();
 
+    // Cursor objects whose classes define DESTROY. Weak-ref sweeps already
+    // clean unreachable weak referents; this registry covers DBIC-style
+    // storage cursors that are not themselves weakened, but whose finish()
+    // side-effect must happen deterministically.
+    private static final Set<RuntimeBase> destroyableObjects =
+            Collections.synchronizedSet(Collections.newSetFromMap(new IdentityHashMap<>()));
+
     // DESTROY rescue detection: when DESTROY stores $self in a hash element,
     // the object should survive (like Perl 5's Schema::DESTROY self-save pattern).
     // These fields track the current DESTROY target so RuntimeHash.put can detect
@@ -45,6 +56,34 @@ public static boolean isInsideDestroy() {
         return currentDestroyTarget != null;
     }
 
+    public static void registerIfDestroyable(RuntimeBase referent, int blessId) {
+        if (referent == null || blessId == 0) return;
+        String className = NameNormalizer.getBlessStr(blessId);
+        if (className != null
+                && className.endsWith("::Cursor")
+                && classHasDestroy(blessId, className)) {
+            destroyableObjects.add(referent);
+        } else {
+            destroyableObjects.remove(referent);
+        }
+    }
+
+    public static void unregisterDestroyable(RuntimeBase referent) {
+        if (referent != null) {
+            destroyableObjects.remove(referent);
+        }
+    }
+
+    public static ArrayList<RuntimeBase> snapshotDestroyableObjects() {
+        synchronized (destroyableObjects) {
+            return new ArrayList<>(destroyableObjects);
+        }
+    }
+
+    public static boolean hasDestroyableObjects() {
+        return !destroyableObjects.isEmpty();
+    }
+
     // Rescued objects whose weak refs need deferred clearing.
     // We cannot clear weak refs immediately after rescue because that would also
     // clear back-references from sibling objects (e.g., $source->{schema}) that
@@ -164,6 +203,7 @@ public static void callDestroy(RuntimeBase referent) {
             }
             return;
         }
+        unregisterDestroyable(referent);
 
         // Phase 3 (refcount_alignment_plan.md): Resurrection re-fire.
         // If a prior DESTROY left refCount > 0 (object resurrected by a
@@ -488,7 +528,7 @@ private static void doCallDestroy(RuntimeBase referent, String className) {
             if (savedTarget == null && sweepPendingAfterOuterDestroy
                     && !ModuleInitGuard.inModuleInit()) {
                 sweepPendingAfterOuterDestroy = false;
-                ReachabilityWalker.sweepWeakRefs(false);
+                ReachabilityWalker.sweepWeakRefs(false, false);
             }
         }
     }
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/ErrorMessageUtil.java b/src/main/java/org/perlonjava/runtime/runtimetypes/ErrorMessageUtil.java
index 06987d297..f91bdbab0 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/ErrorMessageUtil.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/ErrorMessageUtil.java
@@ -538,6 +538,22 @@ public SourceLocation getSourceLocationAccurate(int index) {
         return new SourceLocation(currentFileName, lineNumber);
     }
 
+    public int getSourceOffset(int index) {
+        if (index < 0 || tokens == null) {
+            return -1;
+        }
+        int offset = 0;
+        int limit = Math.min(index, tokens.size());
+        for (int i = 0; i < limit; i++) {
+            LexerToken tok = tokens.get(i);
+            if (tok.type == LexerTokenType.EOF) {
+                break;
+            }
+            offset += tok.text.length();
+        }
+        return offset;
+    }
+
     private static boolean isUnquotedLineFilenameToken(LexerToken token) {
         return token.type != LexerTokenType.WHITESPACE
                 && token.type != LexerTokenType.NEWLINE
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/MortalList.java b/src/main/java/org/perlonjava/runtime/runtimetypes/MortalList.java
index d9d6e3236..86199d223 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/MortalList.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/MortalList.java
@@ -931,8 +931,12 @@ private static void maybeAutoSweep() {
                 immediateWeakSweepRequested = false;
                 lastAutoSweepNanos = System.nanoTime();
             }
-            // Quiet mode handles ordinary statement-boundary checks.
-            int cleared = ReachabilityWalker.sweepWeakRefs(true);
+            // Quiet auto-sweeps run from normal statement-boundary checks.
+            // Do not force HotSpot GC here: current live-lexical tracking is
+            // driven by MyVarCleanupStack, and forcing JVM GC at this cadence
+            // dominates DBIC-scale runtimes. Keep the old forced behavior only
+            // for the diagnostic "sweep every flush" mode.
+            int cleared = ReachabilityWalker.sweepWeakRefs(true, FORCE_SWEEP_EVERY_FLUSH);
             if (AUTO_GC_DEBUG) {
                 System.err.println("DBG auto-sweep cleared=" + cleared);
             }
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/ReachabilityWalker.java b/src/main/java/org/perlonjava/runtime/runtimetypes/ReachabilityWalker.java
index 34f02b5e5..d8b9646ad 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/ReachabilityWalker.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/ReachabilityWalker.java
@@ -1292,6 +1292,10 @@ public static int sweepWeakRefs() {
         return sweepWeakRefs(false);
     }
 
+    public static int sweepWeakRefs(boolean quiet) {
+        return sweepWeakRefs(quiet, true);
+    }
+
     /**
      * Run a reachability sweep. When {@code quiet} is true, only clear
      * weak refs for unreachable objects — do NOT fire DESTROY or drain
@@ -1302,9 +1306,11 @@ public static int sweepWeakRefs() {
      * @param quiet if true, skip DESTROY invocations
      * @return number of weak-ref entries cleared
      */
-    public static int sweepWeakRefs(boolean quiet) {
+    public static int sweepWeakRefs(boolean quiet, boolean forceJvmGc) {
         if (!WeakRefRegistry.weakRefsExist) return 0;
-        ScalarRefRegistry.forceGcAndSnapshot();
+        if (forceJvmGc) {
+            ScalarRefRegistry.forceGcAndSnapshot();
+        }
         if (!quiet) {
             // Explicit sweeps drain rescued objects. Quiet auto-sweeps run
             // during user workflows and must not clear DBIC Schema rescue
@@ -1367,6 +1373,24 @@ && isCapturedByWeakBackrefCode(referent)) {
                 toClear.add(referent);
             }
         }
+        for (RuntimeBase referent : DestroyDispatch.snapshotDestroyableObjects()) {
+            if (referent == null
+                    || referent.destroyFired
+                    || referent.currentlyDestroying
+                    || referent.refCount == Integer.MIN_VALUE) {
+                continue;
+            }
+            if (live.contains(referent)) {
+                continue;
+            }
+            if ((referent instanceof RuntimeHash || referent instanceof RuntimeArray)
+                    && referent.localBindingExists) {
+                continue;
+            }
+            if (!toClear.contains(referent)) {
+                toClear.add(referent);
+            }
+        }
         int cleared = 0;
         for (RuntimeBase referent : toClear) {
             // Phase I: auto-sweep (quiet) now fires DESTROY on blessed
@@ -1394,6 +1418,45 @@ && isCapturedByWeakBackrefCode(referent)) {
         return cleared;
     }
 
+    /**
+     * Sweep only objects registered by {@link DestroyDispatch} as needing
+     * deterministic DESTROY side effects even when they are not weak-ref
+     * referents. This is intentionally narrower than {@link #sweepWeakRefs}:
+     * it does not clear unrelated weak references and it can be used from hot
+     * DBI statement-polling paths without forcing a JVM GC.
+     */
+    public static int sweepDestroyableObjects(boolean forceJvmGc) {
+        if (!DestroyDispatch.hasDestroyableObjects()) return 0;
+        if (forceJvmGc) {
+            ScalarRefRegistry.forceGcAndSnapshot();
+        }
+        ReachabilityWalker w = new ReachabilityWalker();
+        return destroyUnreachableDestroyables(w.walk());
+    }
+
+    private static int destroyUnreachableDestroyables(Set<RuntimeBase> live) {
+        int destroyed = 0;
+        for (RuntimeBase referent : DestroyDispatch.snapshotDestroyableObjects()) {
+            if (referent == null
+                    || referent.destroyFired
+                    || referent.currentlyDestroying
+                    || referent.refCount == Integer.MIN_VALUE) {
+                continue;
+            }
+            if (live.contains(referent)) {
+                continue;
+            }
+            if ((referent instanceof RuntimeHash || referent instanceof RuntimeArray)
+                    && referent.localBindingExists) {
+                continue;
+            }
+            referent.refCount = Integer.MIN_VALUE;
+            DestroyDispatch.callDestroy(referent);
+            destroyed++;
+        }
+        return destroyed;
+    }
+
     private static boolean isCapturedByWeakBackrefCode(RuntimeBase target) {
         for (RuntimeBase referent : WeakRefRegistry.snapshotWeakRefReferents()) {
             if (referent instanceof RuntimeCode code
diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeCode.java b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeCode.java
index 724e17bd6..fb7c462fd 100644
--- a/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeCode.java
+++ b/src/main/java/org/perlonjava/runtime/runtimetypes/RuntimeCode.java
@@ -674,6 +674,11 @@ private RuntimeList detachTryExpressionLvalueResult(RuntimeList result, int call
      */
     public String cvStartFile;
     public int cvStartLine;
+    public String deparseSourceText;
+    public int deparseFlags;
+    public int deparseSourceOffset = -1;
+    public static final int DEPARSE_FLAG_STRICT = 1;
+    public static final int DEPARSE_FLAG_WARNINGS = 2;
     /**
      * True when the parser recognized this CV as a compile-time constant sub
      * (for example {@code sub foo () { 1 }}). {@link #constantValue} covers
@@ -949,6 +954,9 @@ public RuntimeCode cloneForClosure() {
         clone.installedViaAnonGlobAssign = this.installedViaAnonGlobAssign;
         clone.cvStartFile = this.cvStartFile;
         clone.cvStartLine = this.cvStartLine;
+        clone.deparseSourceText = this.deparseSourceText;
+        clone.deparseFlags = this.deparseFlags;
+        clone.deparseSourceOffset = this.deparseSourceOffset;
         clone.isConstantCv = this.isConstantCv;
         clone.isStatic = this.isStatic;
         clone.isDeclared = this.isDeclared;
@@ -2486,6 +2494,30 @@ public static RuntimeScalar makeCodeObject(
             String packageName,
             String cvStartFile,
             int cvStartLine) throws Exception {
+        return makeCodeObject(codeObject, prototype, packageName, cvStartFile, cvStartLine, null, 0);
+    }
+
+    public static RuntimeScalar makeCodeObject(
+            Object codeObject,
+            String prototype,
+            String packageName,
+            String cvStartFile,
+            int cvStartLine,
+            String deparseSourceText,
+            int deparseFlags) throws Exception {
+        return makeCodeObject(codeObject, prototype, packageName, cvStartFile, cvStartLine,
+                deparseSourceText, deparseFlags, -1);
+    }
+
+    public static RuntimeScalar makeCodeObject(
+            Object codeObject,
+            String prototype,
+            String packageName,
+            String cvStartFile,
+            int cvStartLine,
+            String deparseSourceText,
+            int deparseFlags,
+            int deparseSourceOffset) throws Exception {
         // Retrieve the class of the provided code object
         Class<?> clazz = codeObject.getClass();
 
@@ -2505,6 +2537,9 @@ public static RuntimeScalar makeCodeObject(
         if (cvStartLine > 0) {
             code.cvStartLine = cvStartLine;
         }
+        code.deparseSourceText = deparseSourceText;
+        code.deparseFlags = deparseFlags;
+        code.deparseSourceOffset = deparseSourceOffset;
 
         // Look up pad constants registered at compile time for this class.
         // These track cached string literals referenced via \ inside the sub,
diff --git a/src/main/perl/lib/B/Deparse.pm b/src/main/perl/lib/B/Deparse.pm
index 2af003440..8ea2b50ba 100644
--- a/src/main/perl/lib/B/Deparse.pm
+++ b/src/main/perl/lib/B/Deparse.pm
@@ -72,22 +72,40 @@ sub _source_visible_anon_sub {
     my $cop = eval { $cv->START } or return;
     my $file = eval { $cop->file } or return;
     my $line = eval { $cop->line } || 0;
-    return if $line <= 0 || $file eq '-e' || !-f $file;
+    return if $line <= 0;
+
+    my ($runtime_source, $flags, $source_offset) = _runtime_deparse_info($coderef);
+    if (defined $runtime_source && length $runtime_source) {
+        my $block = _extract_source_visible_block($runtime_source, $line, $flags, $source_offset);
+        return $block if defined $block;
+    }
+
+    return if $file eq '-e' || !-f $file;
 
     open my $fh, '<', $file or return;
     my @lines = <$fh>;
     close $fh;
 
     my $source = join '', @lines;
-    return _extract_source_visible_block($source, $line);
+    return _extract_source_visible_block($source, $line, $flags, $source_offset);
+}
+
+sub _runtime_deparse_info {
+    my ($coderef) = @_;
+
+    return unless eval { require Internals; 1 };
+    my @info = eval { Internals::jperl_cv_deparse_info($coderef) };
+    return unless @info;
+    return @info;
 }
 
 sub _extract_source_visible_block {
-    my ($source, $target_line) = @_;
+    my ($source, $target_line, $flags, $source_offset) = @_;
 
     my @stack;
     my @candidates;
     my $line = 1;
+    my $line_start = 0;
     for (my $i = 0; $i < length($source); $i++) {
         my $ch = substr($source, $i, 1);
         if ($ch eq '{') {
@@ -100,11 +118,27 @@ sub _extract_source_visible_block {
             next unless $start_line <= $target_line && $target_line <= $line;
             push @candidates, [$start, $i];
         } elsif ($ch eq "\n") {
-            $line++;
+            my $line_text = substr($source, $line_start, $i - $line_start);
+            if ($line_text =~ /^\s*#line\s+(\d+)/) {
+                $line = $1;
+            } else {
+                $line++;
+            }
+            $line_start = $i + 1;
         }
     }
     return unless @candidates;
 
+    if (defined $source_offset && $source_offset >= 0) {
+        my @containing = grep { $_->[0] <= $source_offset && $source_offset <= $_->[1] } @candidates;
+        if (@containing) {
+            @candidates = @containing;
+        } else {
+            my @after = grep { $_->[0] >= $source_offset } @candidates;
+            @candidates = @after if @after;
+        }
+    }
+
     @candidates = sort {
         ($a->[1] - $a->[0]) <=> ($b->[1] - $b->[0])
             || $b->[0] <=> $a->[0]
@@ -114,7 +148,16 @@ sub _extract_source_visible_block {
     my $body = substr($source, $brace + 1, $end - $brace - 1);
     $body =~ s/^\s+//;
     $body =~ s/\s+$//;
+    return if defined($source_offset) && $source_offset == -1
+        && $body =~ /\A\{\s*use\s+(?:strict|warnings)\b/s;
     $body .= ';' if length($body) && $body !~ /[;}]\z/;
+    if ($flags) {
+        my @lines;
+        push @lines, 'use warnings;' if $flags & 2;
+        push @lines, 'use strict;' if $flags & 1;
+        push @lines, split /\n/, $body;
+        return "{\n" . join('', map { "    $_\n" } @lines) . "}";
+    }
     return "{ $body }";
 }
 
diff --git a/src/main/perl/lib/CPAN/Config.pm b/src/main/perl/lib/CPAN/Config.pm
index fc0c59367..d0b812556 100644
--- a/src/main/perl/lib/CPAN/Config.pm
+++ b/src/main/perl/lib/CPAN/Config.pm
@@ -78,12 +78,16 @@ sub _bootstrap_prefs {
         'Readonly.yml'               => 'PerlOnJava/CpanDistroprefs/Readonly.yml',
         'String-Print.yml'           => 'PerlOnJava/CpanDistroprefs/String-Print.yml',
         'String-ShellQuote.yml'      => 'PerlOnJava/CpanDistroprefs/String-ShellQuote.yml',
+        'Template.yml'               => 'PerlOnJava/CpanDistroprefs/Template.yml',
         'Test-Differences.yml'       => 'PerlOnJava/CpanDistroprefs/Test-Differences.yml',
+        'Parse-RecDescent.yml'       => 'PerlOnJava/CpanDistroprefs/Parse-RecDescent.yml',
+        'Crypt-URandom.yml'          => 'PerlOnJava/CpanDistroprefs/Crypt-URandom.yml',
         'Hook-LexWrap.yml'           => 'PerlOnJava/CpanDistroprefs/Hook-LexWrap.yml',
         'Type-Tiny.yml'              => 'PerlOnJava/CpanDistroprefs/Type-Tiny.yml',
         'CGI.yml'                    => 'PerlOnJava/CpanDistroprefs/CGI.yml',
         'CGI-Simple.yml'             => 'PerlOnJava/CpanDistroprefs/CGI-Simple.yml',
         'HTML-Parser.yml'            => 'PerlOnJava/CpanDistroprefs/HTML-Parser.yml',
+        'XML-Filter-GenericChunk.yml' => 'PerlOnJava/CpanDistroprefs/XML-Filter-GenericChunk.yml',
         'HTTP-Message.yml'           => 'PerlOnJava/CpanDistroprefs/HTTP-Message.yml',
         'HTTP-Response-Encoding.yml' => 'PerlOnJava/CpanDistroprefs/HTTP-Response-Encoding.yml',
         'HTTP-Daemon.yml'            => 'PerlOnJava/CpanDistroprefs/HTTP-Daemon.yml',
@@ -205,6 +209,12 @@ sub _bootstrap_patches {
           'PerlOnJava/CpanPatches/Type-Tiny-2.010001/SkipRegexCallbackTests.patch' ],
         [ 'PerlIO-via-Timeout-0.32/SkipViaRuntimeTest.patch',
           'PerlOnJava/CpanPatches/PerlIO-via-Timeout-0.32/SkipViaRuntimeTest.patch' ],
+        [ 'Crypt-URandom-0.55/PerlOnJavaTests.patch',
+          'PerlOnJava/CpanPatches/Crypt-URandom-0.55/PerlOnJavaTests.patch' ],
+        [ 'Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch',
+          'PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch' ],
+        [ 'Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch',
+          'PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch' ],
     );
 
     my $slurp = sub {
diff --git a/src/main/perl/lib/CPAN/Distribution.pm b/src/main/perl/lib/CPAN/Distribution.pm
index 614dadbc1..696ee01fb 100644
--- a/src/main/perl/lib/CPAN/Distribution.pm
+++ b/src/main/perl/lib/CPAN/Distribution.pm
@@ -2554,7 +2554,9 @@ is part of the perl-%s distribution. To install that, you need to run
         next if defined $v;
         $env{$k} = '';
     }
-    local @ENV{keys %env} = values %env;
+    my @env_keys = keys %env;
+    local @ENV{@env_keys};
+    @ENV{@env_keys} = @env{@env_keys} if @env_keys;
     my $satisfied = eval { $self->satisfy_requires };
     if ($@) {
         return $self->goodbye($@);
diff --git a/src/main/perl/lib/DBD/JDBC.pm b/src/main/perl/lib/DBD/JDBC.pm
index 0da20d939..0d636a09d 100644
--- a/src/main/perl/lib/DBD/JDBC.pm
+++ b/src/main/perl/lib/DBD/JDBC.pm
@@ -82,6 +82,7 @@ use strict;
 # we install via glob aliasing to an explicitly-named helper.
 sub _do_impl {
     my ($dbh, $statement, $attr, @params) = @_;
+    DBI::_cleanup_before_ddl($statement);
     my $sth = $dbh->prepare($statement, $attr) or return undef;
     $sth->execute(@params) or do { $sth->finish; return undef };
     my $rows = $sth->rows;
diff --git a/src/main/perl/lib/DBI.pm b/src/main/perl/lib/DBI.pm
index 3e17190cf..693f961ad 100644
--- a/src/main/perl/lib/DBI.pm
+++ b/src/main/perl/lib/DBI.pm
@@ -8,6 +8,7 @@ use Exporter 'import';
 our $VERSION = '1.643';
 our $stderr = 2000000000;
 our ($err, $errstr, $state);
+our ($ACTIVE_FETCH_FREETMPS_RUNNING, $DDL_CLEANUP_RUNNING);
 our %InstalledDrivers;
 our $SqlEngineStorePatched;
 our $AnyDataDestroyPatched;
@@ -291,6 +292,22 @@ sub _handle_error_with_handler {
     return undef;
 }
 
+sub _cleanup_before_ddl {
+    my ($statement) = @_;
+    return unless defined $statement && !ref($statement);
+    return unless $statement =~ /^\s*(?:--[^\n]*\n\s*)*(?:CREATE|DROP|ALTER|VACUUM|REINDEX)\b/i;
+    return if $DDL_CLEANUP_RUNNING;
+
+    local $DDL_CLEANUP_RUNNING = 1;
+    eval {
+        require Internals;
+        Internals::jperl_freetmps();
+        Internals::jperl_sweep_destroyables_no_jvm_gc();
+        1;
+    };
+    return 1;
+}
+
 sub _append_isa {
     my ($pkg, $base) = @_;
     no strict 'refs';
@@ -714,6 +731,18 @@ our $MAX_CACHED_CONNECTIONS = 10;
 # $dbh->FETCH('Active') explicitly, so we need method wrappers.
 sub FETCH {
     my ($self, $key) = @_;
+    if (($self->{Type} || '') eq 'st'
+            && $key eq 'Active'
+            && $self->{$key}
+            && !$ACTIVE_FETCH_FREETMPS_RUNNING) {
+        local $ACTIVE_FETCH_FREETMPS_RUNNING = 1;
+        eval {
+            require Internals;
+            Internals::jperl_freetmps();
+            Internals::jperl_sweep_destroyables_no_jvm_gc();
+            1;
+        };
+    }
     return $self->{$key};
 }
 
@@ -731,6 +760,7 @@ sub STORE {
 
 sub do {
     my ($dbh, $statement, $attr, @params) = @_;
+    _cleanup_before_ddl($statement) if _is_jdbc_handle($dbh);
     my $sth = $dbh->prepare($statement, $attr) or return undef;
     $sth->execute(@params) or return undef;
     my $rows = $sth->rows;
@@ -855,16 +885,22 @@ sub state {
 
 sub selectrow_arrayref {
     my ($dbh, $statement, $attr, @params) = @_;
-    my $sth = $dbh->prepare($statement, $attr) or return undef;
+    my $sth = ref($statement) ? $statement : $dbh->prepare($statement, $attr)
+        or return undef;
     $sth->execute(@params) or return undef;
-    return $sth->fetchrow_arrayref();
+    my $row = $sth->fetchrow_arrayref()
+        and $sth->finish;
+    return $row;
 }
 
 sub selectrow_hashref {
     my ($dbh, $statement, $attr, @params) = @_;
-    my $sth = $dbh->prepare($statement, $attr) or return undef;
+    my $sth = ref($statement) ? $statement : $dbh->prepare($statement, $attr)
+        or return undef;
     $sth->execute(@params) or return undef;
-    return $sth->fetchrow_hashref();
+    my $row = $sth->fetchrow_hashref()
+        and $sth->finish;
+    return $row;
 }
 
 sub fetchrow_arrayref {
diff --git a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Crypt-URandom.yml b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Crypt-URandom.yml
new file mode 100644
index 000000000..4929dd156
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Crypt-URandom.yml
@@ -0,0 +1,13 @@
+---
+comment: |
+  PerlOnJava distroprefs for Crypt::URandom.
+
+  The distribution's core RNG paths work under PerlOnJava, including the
+  bundled getrandom path. A few upstream tests require POSIX fork or force the
+  pure-Perl /dev/urandom fallback by overriding CORE::GLOBAL::{read,sysread,
+  sysopen}; those overrides are not meaningful when getrandom is available.
+  Patch only those test files and keep the rest of the suite active.
+match:
+  distribution: "^DDICK/Crypt-URandom-0\\.55"
+patches:
+  - "Crypt-URandom-0.55/PerlOnJavaTests.patch"
diff --git a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Parse-RecDescent.yml b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Parse-RecDescent.yml
new file mode 100644
index 000000000..e45c152a3
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Parse-RecDescent.yml
@@ -0,0 +1,13 @@
+---
+comment: |
+  PerlOnJava distroprefs for Parse::RecDescent.
+
+  The runtime parser and dependent precompile tests pass. The standalone
+  precompiled-parser test generates a large self-contained parser that
+  overflows the JVM stack under PerlOnJava, and PGObject only needs the normal
+  runtime parser. Patch just that standalone test block.
+match:
+  distribution: "^JTBRAUN/Parse-RecDescent-"
+patches:
+  - "Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch"
+  - "Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch"
diff --git a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Template.yml b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Template.yml
new file mode 100644
index 000000000..8252c3db7
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Template.yml
@@ -0,0 +1,16 @@
+---
+comment: |
+  PerlOnJava distroprefs for Template Toolkit.
+
+  Template Toolkit's Makefile.PL prompts before building the optional
+  Template::Stash::XS implementation. PerlOnJava cannot build XS, and
+  CPAN's generic PERL_MM_USE_DEFAULT handling would accept the upstream
+  default of "yes", so configure it explicitly for the pure-Perl stash.
+match:
+  distribution: '/Template-Toolkit-[0-9]'
+pl:
+  args:
+    - TT_XS_ENABLE=n
+    - TT_XS_DEFAULT=n
+    - TT_ACCEPT=y
+    - TT_QUIET=y
diff --git a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Test-Differences.yml b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Test-Differences.yml
index a8c4b509f..903d59022 100644
--- a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Test-Differences.yml
+++ b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/Test-Differences.yml
@@ -2,11 +2,7 @@
 comment: |
   PerlOnJava distroprefs for Test::Differences.
 
-  The module itself loads and produces diffs, but several upstream tests compare
-  exact captured diagnostics. PerlOnJava currently reports different `-e` line
-  numbers and anonymous sub deparse text, so allow CPAN to continue past those
-  harness-only failures.
+  No test override is required. Keep this file bootstrapped so older
+  PerlOnJava installations replace the former ignore-failures preference.
 match:
   distribution: "^DCANTRELL/Test-Differences-"
-test:
-  commandline: "PERLONJAVA_TEST_IGNORE_FAILURES"
diff --git a/src/main/perl/lib/PerlOnJava/CpanDistroprefs/XML-Filter-GenericChunk.yml b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/XML-Filter-GenericChunk.yml
new file mode 100644
index 000000000..dbb9ec8d4
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanDistroprefs/XML-Filter-GenericChunk.yml
@@ -0,0 +1,16 @@
+---
+comment: |
+  PerlOnJava distroprefs for XML::Filter::GenericChunk.
+
+  Upstream only declares XML::SAX::Base, but the test suite also loads
+  XML::SAX::DocumentLocator and XML::NamespaceSupport. Clean CPAN installs
+  therefore miss prerequisites that system Perl often has already. Make them
+  explicit so jcpan stages the normal pure-Perl XML stack first.
+match:
+  distribution: "^PHISH/XML-Filter-GenericChunk-"
+depends:
+  requires:
+    XML::LibXML: 1.40
+    XML::NamespaceSupport: 0
+    XML::SAX: 0
+    XML::SAX::Base: 1.03
diff --git a/src/main/perl/lib/PerlOnJava/CpanPatches/Crypt-URandom-0.55/PerlOnJavaTests.patch b/src/main/perl/lib/PerlOnJava/CpanPatches/Crypt-URandom-0.55/PerlOnJavaTests.patch
new file mode 100644
index 000000000..df0703a2b
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanPatches/Crypt-URandom-0.55/PerlOnJavaTests.patch
@@ -0,0 +1,90 @@
+--- t/core_fork.t.orig
++++ t/core_fork.t
+@@ -3,5 +3,15 @@
+ use strict;
+ use warnings;
++BEGIN {
++    my $is_perlonjava = ($ENV{PERLONJAVA_EXECUTABLE} || $^X || '')
++        =~ m{(?:^|[\\/])jperl(?:\\.bat)?$};
++    if ($is_perlonjava) {
++        require Test::More;
++        Test::More::plan(skip_all =>
++            'PerlOnJava does not implement fork()');
++    }
++}
++
+ use Test::More;
+ 
+ SKIP: {
+--- t/core_fork_pp.t.orig
++++ t/core_fork_pp.t
+@@ -3,5 +3,15 @@
+ use strict;
+ use warnings;
++BEGIN {
++    my $is_perlonjava = ($ENV{PERLONJAVA_EXECUTABLE} || $^X || '')
++        =~ m{(?:^|[\\/])jperl(?:\\.bat)?$};
++    if ($is_perlonjava) {
++        require Test::More;
++        Test::More::plan(skip_all =>
++            'PerlOnJava does not implement fork()');
++    }
++}
++
+ use Test::More;
+ use English();
+ use Carp();
+--- t/core_read.t.orig
++++ t/core_read.t
+@@ -3,5 +3,15 @@
+ use strict;
+ use warnings;
++BEGIN {
++    my $is_perlonjava = ($ENV{PERLONJAVA_EXECUTABLE} || $^X || '')
++        =~ m{(?:^|[\\/])jperl(?:\\.bat)?$};
++    if ($is_perlonjava) {
++        require Test::More;
++        Test::More::plan(skip_all =>
++            'PerlOnJava uses getrandom, so CORE::GLOBAL::read overrides do not exercise Crypt::URandom fallback');
++    }
++}
++
+ use Test::More;
+ use English();
+ use Carp();
+--- t/core_partial_read.t.orig
++++ t/core_partial_read.t
+@@ -3,5 +3,15 @@
+ use strict;
+ use warnings;
++BEGIN {
++    my $is_perlonjava = ($ENV{PERLONJAVA_EXECUTABLE} || $^X || '')
++        =~ m{(?:^|[\\/])jperl(?:\\.bat)?$};
++    if ($is_perlonjava) {
++        require Test::More;
++        Test::More::plan(skip_all =>
++            'PerlOnJava uses getrandom, so CORE::GLOBAL::read overrides do not exercise Crypt::URandom fallback');
++    }
++}
++
+ use Test::More;
+ use English();
+ use Carp();
+--- t/core_sysopen.t.orig
++++ t/core_sysopen.t
+@@ -3,5 +3,15 @@
+ use strict;
+ use warnings;
++BEGIN {
++    my $is_perlonjava = ($ENV{PERLONJAVA_EXECUTABLE} || $^X || '')
++        =~ m{(?:^|[\\/])jperl(?:\\.bat)?$};
++    if ($is_perlonjava) {
++        require Test::More;
++        Test::More::plan(skip_all =>
++            'PerlOnJava uses getrandom, so CORE::GLOBAL::sysopen overrides do not exercise Crypt::URandom fallback');
++    }
++}
++
+ use Test::More;
+ use English();
+ use Carp();
diff --git a/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch b/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch
new file mode 100644
index 000000000..4ff6725ab
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipReproducibleStandalone.patch
@@ -0,0 +1,13 @@
+--- t/reproducible.t.orig
++++ t/reproducible.t
+@@ -417,5 +417,9 @@
+ for (0..5) {
+     my $new_parser = CompileParser($_);
+ 
+-    ok($new_parser eq $reference_parser, "parsers match");
++    SKIP: {
++        skip "PerlOnJava standalone precompiled parser text is not byte-for-byte reproducible", 1
++            if (($ENV{PERLONJAVA_EXECUTABLE} || '') || (($^X || '') =~ /(?:^|[\/\\])jperl(?:\z|[.])/));
++        ok($new_parser eq $reference_parser, "parsers match");
++    }
+ }
diff --git a/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch b/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch
new file mode 100644
index 000000000..b12c7aa8d
--- /dev/null
+++ b/src/main/perl/lib/PerlOnJava/CpanPatches/Parse-RecDescent-1.967015/SkipStandalonePrecompile.patch
@@ -0,0 +1,17 @@
+--- t/precompile.t.orig
++++ t/precompile.t
+@@ -23,6 +23,14 @@
+ for my $standalone (0..1) {
+     my $standalone_str = $standalone ? 'standalone' : 'dependent';
+     my $class = "TestParser$standalone_str";
++
++    if ($standalone && (($ENV{PERLONJAVA_EXECUTABLE} || '') || (($^X || '') =~ /(?:^|[\/\\])jperl(?:\z|[.])/))) {
++        SKIP: {
++            skip "PerlOnJava overflows the JVM stack in standalone precompiled parser", 7;
++        }
++        next;
++    }
++
+     my $pm_filename = $class . '.pm';
+ 
+     if (-e $pm_filename) {
diff --git a/src/main/perl/lib/namespace/autoclean.pm b/src/main/perl/lib/namespace/autoclean.pm
index ae3b0cd18..7ede9e2c2 100644
--- a/src/main/perl/lib/namespace/autoclean.pm
+++ b/src/main/perl/lib/namespace/autoclean.pm
@@ -154,6 +154,10 @@ sub _method_check {
 
         return 1 if $code_stash eq $package;   # Defined locally
         return 1 if $code_stash eq 'constant'; # Constant subs
+        # The bundled pure-Perl Class::XSAccessor installs accessors into the
+        # target stash, but the coderefs keep Class::XSAccessor::__ANON__
+        # subnames. Those are generated methods, not imports to clean.
+        return 1 if $code_stash eq 'Class::XSAccessor';
         # Companion/helper packages (e.g. DateTime::PP for DateTime) install
         # functions via glob assignment — these are intentional methods, not imports.
         # In PerlOnJava, method calls are resolved at runtime through the stash,
diff --git a/src/test/resources/unit/b_deparse_dbic_eval_snippets.t b/src/test/resources/unit/b_deparse_dbic_eval_snippets.t
new file mode 100644
index 000000000..8e44cca01
--- /dev/null
+++ b/src/test/resources/unit/b_deparse_dbic_eval_snippets.t
@@ -0,0 +1,29 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 2;
+use B::Deparse;
+
+my $deparse = B::Deparse->new;
+
+my $dbic_generated = <<'PERL';
+  { use strict; use warnings; use warnings FATAL => 'uninitialized';
+$_ = [{ "year" => $_->[1] }] for @{$_[0]}
+  }
+PERL
+
+my $dbic_expected = <<'PERL';
+  { use strict; use warnings FATAL => 'uninitialized';
+$_ = [
+    { year => $_->[1] },
+  ] for @{$_[0]}
+  }
+PERL
+
+my @dbic_like = map {
+    my $cref = eval "sub { $_ }" or die $@;
+    $deparse->coderef2text($cref);
+} ($dbic_generated, $dbic_expected);
+
+is($dbic_like[0], $dbic_like[1], 'pragma-wrapped eval snippets do not compare raw source');
+is($dbic_like[0], '{ "DUMMY" }', 'complex eval source falls back to placeholder');
diff --git a/src/test/resources/unit/b_deparse_source_visible_anon_sub.t b/src/test/resources/unit/b_deparse_source_visible_anon_sub.t
new file mode 100644
index 000000000..6020c9a55
--- /dev/null
+++ b/src/test/resources/unit/b_deparse_source_visible_anon_sub.t
@@ -0,0 +1,28 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 8;
+use B::Deparse;
+
+my $deparse = B::Deparse->new;
+my $one = $deparse->coderef2text(sub { 1 });
+my $two = $deparse->coderef2text(sub { 2 });
+
+like($one, qr/use warnings;\n    use strict;\n    1;/, 'source-visible anon sub includes active pragmas and body');
+like($two, qr/use warnings;\n    use strict;\n    2;/, 'second source-visible anon sub keeps its own body');
+isnt($one, $two, 'different anon sub bodies deparse distinctly');
+
+my $inline_source = qq{#line 0 "-e"\nuse strict;\nuse warnings;\n#line 1 "-e"\nmy \$c = sub { 3 };\n};
+my $inline = B::Deparse::_extract_source_visible_block($inline_source, 1, 3);
+like($inline, qr/use warnings;\n    use strict;\n    3;/, 'source-visible anon sub honours inline #line directives');
+
+my $leading_inline_source = qq{#line 0 "-e"\nuse strict;\nuse warnings;\n#line 1 "-e"\n\nEND { }\nmy \$c = sub { 4 };\n};
+my $leading_inline = B::Deparse::_extract_source_visible_block($leading_inline_source, 3, 3);
+like($leading_inline, qr/use warnings;\n    use strict;\n    4;/, 'source-visible anon sub honours leading inline lines');
+
+my ($same_line_one, $same_line_two) = (sub { 5 }, sub { 6 });
+my $same_one = $deparse->coderef2text($same_line_one);
+my $same_two = $deparse->coderef2text($same_line_two);
+like($same_one, qr/use warnings;\n    use strict;\n    5;/, 'source-visible anon sub finds first same-line body');
+like($same_two, qr/use warnings;\n    use strict;\n    6;/, 'source-visible anon sub finds second same-line body');
+isnt($same_one, $same_two, 'same-line anon sub bodies deparse distinctly');
diff --git a/src/test/resources/unit/caller_multiline_data_call_line.t b/src/test/resources/unit/caller_multiline_data_call_line.t
new file mode 100644
index 000000000..f750ce143
--- /dev/null
+++ b/src/test/resources/unit/caller_multiline_data_call_line.t
@@ -0,0 +1,53 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More tests => 5;
+
+sub direct_caller_line {
+    return (caller(0))[2];
+}
+
+my $expected_direct_line = __LINE__ + 1;
+my $direct_line = direct_caller_line(
+    1,
+    2
+);
+is($direct_line, $expected_direct_line, 'ordinary multiline direct call reports opening line');
+
+{
+    package CallerMultilineDataCallLine::Obj;
+    sub new { bless {}, shift }
+    sub method_caller_line {
+        return (caller(0))[2];
+    }
+}
+
+my $expected_method_line = __LINE__ + 1;
+my $method_line = CallerMultilineDataCallLine::Obj->new->method_caller_line(
+    1,
+    2
+);
+is($method_line, $expected_method_line, 'ordinary multiline method call reports opening line');
+
+sub literal_sub_arg_caller_line {
+    return (caller(0))[2];
+}
+
+my $expected_literal_sub_line = __LINE__ + 3;
+my $literal_sub_line = literal_sub_arg_caller_line(
+    sub { 1 }
+);
+is($literal_sub_line, $expected_literal_sub_line, 'literal anon sub argument still reports block line');
+
+my $expected_method_literal_sub_line = __LINE__ + 3;
+my $method_literal_sub_line = CallerMultilineDataCallLine::Obj->new->method_caller_line(
+    sub { 1 }
+);
+is($method_literal_sub_line, $expected_method_literal_sub_line, 'method literal anon sub argument still reports block line');
+
+my $coderef = sub { return (caller(0))[2] };
+my $expected_coderef_line = __LINE__ + 1;
+my $coderef_line = $coderef->(
+    "argument"
+);
+is($coderef_line, $expected_coderef_line, 'ordinary multiline coderef arrow call reports opening line');
diff --git a/src/test/resources/unit/dbi_ddl_sweeps_unreachable_cursor.t b/src/test/resources/unit/dbi_ddl_sweeps_unreachable_cursor.t
new file mode 100644
index 000000000..20a1ca800
--- /dev/null
+++ b/src/test/resources/unit/dbi_ddl_sweeps_unreachable_cursor.t
@@ -0,0 +1,53 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More;
+use DBI;
+
+BEGIN {
+    eval { require DBD::SQLite; 1 }
+        or plan skip_all => 'DBD::SQLite required';
+}
+
+{
+    package DBICTest::Cursor;
+
+    our $DESTROYED = 0;
+
+    sub new {
+        my ($class, $sth) = @_;
+        return bless { sth => $sth }, $class;
+    }
+
+    sub DESTROY {
+        my $self = shift;
+        $DESTROYED++;
+        eval { $self->{sth}->finish if $self->{sth} };
+    }
+}
+
+my $dbh = DBI->connect(
+    'dbi:SQLite:dbname=:memory:',
+    '',
+    '',
+    { RaiseError => 1, PrintError => 0 },
+);
+
+$dbh->do('CREATE TABLE items (id INTEGER PRIMARY KEY)');
+$dbh->do('INSERT INTO items (id) VALUES (1)');
+
+{
+    my $sth = $dbh->prepare('SELECT id FROM items');
+    $sth->execute;
+    is_deeply($sth->fetchrow_arrayref, [1], 'cursor fetched first row');
+    my $cursor = DBICTest::Cursor->new($sth);
+}
+
+ok(
+    eval { $dbh->do('DROP TABLE items'); 1 },
+    'DDL succeeds after unreachable cursor cleanup',
+) or diag $@;
+
+ok($DBICTest::Cursor::DESTROYED >= 1, 'unreachable cursor was destroyed');
+
+done_testing;
diff --git a/src/test/resources/unit/dbi_selectrow_finish.t b/src/test/resources/unit/dbi_selectrow_finish.t
new file mode 100644
index 000000000..b6d984185
--- /dev/null
+++ b/src/test/resources/unit/dbi_selectrow_finish.t
@@ -0,0 +1,32 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More;
+use DBI;
+
+BEGIN {
+    eval { require DBD::SQLite; 1 }
+        or plan skip_all => 'DBD::SQLite required';
+}
+
+my $dbh = DBI->connect(
+    'dbi:SQLite:dbname=:memory:',
+    '',
+    '',
+    { RaiseError => 1, PrintError => 0 },
+);
+
+$dbh->do('CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT)');
+$dbh->do(q{INSERT INTO items (id, name) VALUES (1, 'one')});
+
+my $array_sth = $dbh->prepare('SELECT name FROM items WHERE id = 1');
+my $array_row = $dbh->selectrow_arrayref($array_sth);
+is_deeply($array_row, ['one'], 'selectrow_arrayref returns the row');
+ok(!$array_sth->FETCH('Active'), 'selectrow_arrayref finishes a successful statement');
+
+my $hash_sth = $dbh->prepare('SELECT name FROM items WHERE id = 1');
+my $hash_row = $dbh->selectrow_hashref($hash_sth);
+is($hash_row->{name}, 'one', 'selectrow_hashref returns the row');
+ok(!$hash_sth->FETCH('Active'), 'selectrow_hashref finishes a successful statement');
+
+done_testing;
diff --git a/src/test/resources/unit/eval_string_seed_alias_cleanup.t b/src/test/resources/unit/eval_string_seed_alias_cleanup.t
new file mode 100644
index 000000000..e2991d1f6
--- /dev/null
+++ b/src/test/resources/unit/eval_string_seed_alias_cleanup.t
@@ -0,0 +1,39 @@
+use strict;
+use warnings;
+use Test::More tests => 3;
+use Scalar::Util qw(weaken);
+
+{
+    package EvalStringSeedAliasCleanup::Cursor;
+    sub DESTROY { $main::destroyed_cursor++ }
+}
+
+{
+    my $x = 41;
+    eval q{
+        package EvalStringSeedAliasCleanup;
+        sub probe { $x + 1 }
+        1;
+    } or die $@;
+}
+
+is(EvalStringSeedAliasCleanup::probe(), 42,
+    'named sub defined in eval keeps captured lexical after seed alias cleanup');
+
+our ($weak_cursor, $destroyed_cursor);
+$destroyed_cursor = 0;
+
+sub eval_with_cursor_lexical {
+    my $cursor = bless {}, 'EvalStringSeedAliasCleanup::Cursor';
+    $weak_cursor = $cursor;
+    weaken($weak_cursor);
+    eval q{ $cursor; 1 } or die $@;
+}
+
+eval_with_cursor_lexical();
+Internals::jperl_gc() if defined &Internals::jperl_gc;
+
+ok(!defined $weak_cursor,
+    'eval seed alias does not keep direct eval lexical alive after scope exit');
+is($destroyed_cursor, 1,
+    'DESTROY fires for eval lexical after seed alias cleanup');
diff --git a/src/test/resources/unit/interpreter_dbic_regressions.t b/src/test/resources/unit/interpreter_dbic_regressions.t
new file mode 100644
index 000000000..c2656f81a
--- /dev/null
+++ b/src/test/resources/unit/interpreter_dbic_regressions.t
@@ -0,0 +1,116 @@
+use strict;
+use warnings;
+use Test::More;
+use File::Temp qw(tempfile);
+
+my $skip_launcher = $^O eq 'MSWin32'
+    || ($^X eq 'jperl' && !-f 'target/perlonjava-5.42.0.jar');
+
+sub run_interpreter_child {
+    my ($code) = @_;
+
+    my ($script_fh, $script_name) = tempfile(SUFFIX => '.pl');
+    print {$script_fh} $code;
+    close $script_fh or die "close child script: $!";
+
+    my ($out_fh, $out_name) = tempfile();
+    my $jperl = $^X eq 'jperl' ? './jperl' : $^X;
+
+    open(my $saved_stdout, '>&', \*STDOUT) or die "save stdout: $!";
+    open(my $saved_stderr, '>&', \*STDERR) or die "save stderr: $!";
+    open(STDOUT, '>&', $out_fh) or die "redirect stdout: $!";
+    open(STDERR, '>&', $out_fh) or die "redirect stderr: $!";
+    my $status = system('timeout', '60', $jperl, '--interpreter', $script_name);
+    open(STDERR, '>&', $saved_stderr) or die "restore stderr: $!";
+    open(STDOUT, '>&', $saved_stdout) or die "restore stdout: $!";
+    close $saved_stderr;
+    close $saved_stdout;
+
+    seek($out_fh, 0, 0);
+    my $output = do { local $/; <$out_fh> };
+    close $out_fh;
+    unlink $out_name;
+    unlink $script_name;
+
+    return ($status, $output);
+}
+
+SKIP: {
+    skip 'nested jperl launcher is unavailable', 8 if $skip_launcher;
+
+    my ($delete_status, $delete_output) = run_interpreter_child(<<'END_CHILD');
+use strict;
+use warnings;
+my $rs_data = { a => 1, b => 2 };
+my $colnames = ['a'];
+delete @{$rs_data}{@$colnames};
+print join(',', sort keys %$rs_data), "\n";
+END_CHILD
+
+    is($delete_status, 0, 'interpreter hashref slice delete exits successfully')
+        or diag $delete_output;
+    is($delete_output, "b\n",
+        'interpreter delete @{$hashref}{@$arrayref} deletes expanded keys');
+
+    my ($coderef_status, $coderef_output) = run_interpreter_child(<<'END_CHILD');
+use strict;
+use warnings;
+BEGIN {
+    package InterpreterDBICRegression::Exporter;
+    sub f { 42 }
+    sub import {
+        my $target = caller;
+        no strict 'refs';
+        *{"${target}::f"} = \&f;
+    }
+    $INC{'InterpreterDBICRegression/Exporter.pm'} = 1;
+}
+package InterpreterDBICRegression::Consumer;
+use InterpreterDBICRegression::Exporter;
+sub g { &f }
+BEGIN { delete $InterpreterDBICRegression::Consumer::{f} }
+package main;
+print InterpreterDBICRegression::Consumer::g(), "\n";
+END_CHILD
+
+    is($coderef_status, 0, 'interpreter pinned &sub call exits successfully')
+        or diag $coderef_output;
+    is($coderef_output, "42\n",
+        'interpreter &sub call keeps parse-time CV after stash cleanup');
+
+    my ($return_status, $return_output) = run_interpreter_child(<<'END_CHILD');
+use strict;
+use warnings;
+sub g { return wantarray ? (1, 2, 19) : 1 }
+sub f { return g() }
+my $x = f();
+my @y = f();
+print "x=$x y=@y\n";
+END_CHILD
+
+    is($return_status, 0, 'interpreter explicit return subcall exits successfully')
+        or diag $return_output;
+    is($return_output, "x=1 y=1 2 19\n",
+        'interpreter evaluates return subcall in caller context');
+
+    my ($return_list_status, $return_list_output) = run_interpreter_child(<<'END_CHILD');
+use strict;
+use warnings;
+my @seen;
+sub g {
+    push @seen, wantarray ? 'list' : 'scalar';
+    return wantarray ? (1, 2, 19) : 1;
+}
+sub f { return (g(), 5) }
+my $x = f();
+my @y = f();
+print "x=$x y=@y seen=@seen\n";
+END_CHILD
+
+    is($return_list_status, 0, 'interpreter explicit return list exits successfully')
+        or diag $return_list_output;
+    is($return_list_output, "x=5 y=1 2 19 5 seen=scalar list\n",
+        'interpreter evaluates return list elements in caller context');
+}
+
+done_testing;
diff --git a/src/test/resources/unit/namespace_autoclean_xsaccessor.t b/src/test/resources/unit/namespace_autoclean_xsaccessor.t
new file mode 100644
index 000000000..113672bb6
--- /dev/null
+++ b/src/test/resources/unit/namespace_autoclean_xsaccessor.t
@@ -0,0 +1,32 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use Test::More;
+
+{
+    package NamespaceAutocleanXSAccessor::Direct;
+    use namespace::autoclean;
+    use Class::XSAccessor accessors => { value => 'value' };
+}
+
+ok(NamespaceAutocleanXSAccessor::Direct->can('value'),
+    'namespace::autoclean keeps Class::XSAccessor-generated accessors');
+
+my $direct = bless { value => 42 }, 'NamespaceAutocleanXSAccessor::Direct';
+is($direct->value, 42, 'generated accessor still works after autoclean');
+
+SKIP: {
+    skip 'Moo is not installed', 1 unless eval { require Moo; 1 };
+
+    {
+    package NamespaceAutocleanXSAccessor::MooClass;
+    Moo->import;
+    namespace::autoclean->import;
+    has('name' => (is => 'ro'));
+    }
+
+    my $moo = NamespaceAutocleanXSAccessor::MooClass->new(name => 'kept');
+    is($moo->name, 'kept', 'Moo accessors generated through Class::XSAccessor survive autoclean');
+}
+
+done_testing;