fix(redirect): fd3 redirection pattern 3>&1 >file now routes correctly

Use interpreter-level pending_fd_output buffer (not ExecResult) to carry
fd3+ content from inner 1>&N redirects to compound-level fd-table routing.
This avoids growing ExecResult (which would cause stack overflow in deep
recursive execution).

Changes:
- Interpreter.pending_fd_output: HashMap<i32, String> for fd3+ output
- apply_redirections fast path: 1>&N (N>=3) moves stdout to pending buffer
- apply_redirections_fd_table: generalized to HashMap-based fd table
  supporting arbitrary fds, consumes pending_fd_output for routing

Closes #1115

Author: chaliy

crates/bashkit/src/interpreter/mod.rs

@@ -485,6 +485,10 @@ pub struct Interpreter {
     /// Persistent fd output table set by `exec N>/path` redirections.
     /// Maps fd number to its output target. Used by `>&N` redirections.
     exec_fd_table: HashMap<i32, FdTarget>,
+    /// Temporary buffer for fd3+ output during compound body execution.
+    /// When `1>&N` (N>=3) is encountered in a simple command, stdout moves here
+    /// so that compound-level redirects (e.g. `3>&1 >file`) can route it correctly.
+    pending_fd_output: HashMap<i32, String>,
     /// Cancellation token: when set to `true`, execution aborts at the next
     /// command boundary with `Error::Cancelled`.
     cancelled: Arc<AtomicBool>,
@@ -804,6 +808,7 @@ impl Interpreter {
             coproc_buffers: HashMap::new(),
             coproc_next_fd: 63,
             exec_fd_table: HashMap::new(),
+            pending_fd_output: HashMap::new(),
             cancelled: Arc::new(AtomicBool::new(false)),
             deferred_proc_subs: Vec::new(),
         }
@@ -5928,6 +5933,20 @@ impl Interpreter {
                                 result.stderr.push_str(&result.stdout);
                                 result.stdout = String::new();
                             }
+                            (src, dst) if dst >= 3 => {
+                                // Move content to pending_fd_output for compound
+                                // redirect routing (e.g. `echo msg 1>&3` inside
+                                // `{ ... } 3>&1 >file`).
+                                let data = if src == 2 {
+                                    std::mem::take(&mut result.stderr)
+                                } else {
+                                    std::mem::take(&mut result.stdout)
+                                };
+                                self.pending_fd_output
+                                    .entry(dst)
+                                    .or_default()
+                                    .push_str(&data);
+                            }
                             _ => {}
                         }
                     }
@@ -5950,9 +5969,13 @@ impl Interpreter {
         mut result: ExecResult,
         redirects: &[Redirect],
     ) -> Result<ExecResult> {
-        // Build fd table: fd1 = stdout pipe, fd2 = stderr pipe
-        let mut fd1 = FdTarget::Stdout;
-        let mut fd2 = FdTarget::Stderr;
+        // Build fd table with support for arbitrary fds (fd1, fd2, fd3+).
+        // Bash processes redirects left-to-right: `3>&1 >file` means
+        // fd3 captures fd1's *current* target (stdout) before fd1 is
+        // redirected to the file.
+        let mut fd_table: HashMap<i32, FdTarget> = HashMap::new();
+        fd_table.insert(1, FdTarget::Stdout);
+        fd_table.insert(2, FdTarget::Stderr);
 
         for redirect in redirects {
             match redirect.kind {
@@ -5977,10 +6000,7 @@ impl Interpreter {
                     } else {
                         FdTarget::WriteFile(path, target_path)
                     };
-                    match redirect.fd {
-                        Some(2) => fd2 = target,
-                        _ => fd1 = target,
-                    }
+                    fd_table.insert(redirect.fd.unwrap_or(1), target);
                 }
                 RedirectKind::Append => {
                     let target_path = self.expand_word(&redirect.target).await?;
@@ -5990,10 +6010,7 @@ impl Interpreter {
                     } else {
                         FdTarget::AppendFile(path, target_path)
                     };
-                    match redirect.fd {
-                        Some(2) => fd2 = target,
-                        _ => fd1 = target,
-                    }
+                    fd_table.insert(redirect.fd.unwrap_or(1), target);
                 }
                 RedirectKind::OutputBoth => {
                     let target_path = self.expand_word(&redirect.target).await?;
@@ -6003,27 +6020,22 @@ impl Interpreter {
                     } else {
                         FdTarget::WriteFile(path, target_path)
                     };
-                    fd1 = target.clone();
-                    fd2 = target;
+                    fd_table.insert(1, target.clone());
+                    fd_table.insert(2, target);
                 }
                 RedirectKind::DupOutput => {
                     let target = self.expand_word(&redirect.target).await?;
                     let target_fd: i32 = target.parse().unwrap_or(1);
                     let src_fd = redirect.fd.unwrap_or(1);
 
-                    // Look up exec_fd_table for persistent fd targets
-                    if let Some(exec_target) = self.exec_fd_table.get(&target_fd).cloned() {
-                        match src_fd {
-                            2 => fd2 = exec_target,
-                            _ => fd1 = exec_target,
-                        }
-                    } else {
-                        match (src_fd, target_fd) {
-                            (2, 1) => fd2 = fd1.clone(),
-                            (1, 2) => fd1 = fd2.clone(),
-                            _ => {}
-                        }
-                    }
+                    // Resolve: exec_fd_table first, then fd_table
+                    let resolved = self
+                        .exec_fd_table
+                        .get(&target_fd)
+                        .cloned()
+                        .or_else(|| fd_table.get(&target_fd).cloned())
+                        .unwrap_or(FdTarget::Stdout);
+                    fd_table.insert(src_fd, resolved);
                 }
                 RedirectKind::Input
                 | RedirectKind::HereString
@@ -6033,21 +6045,23 @@ impl Interpreter {
             }
         }
 
-        // Route original stdout/stderr based on final fd table.
-        // Collect file writes to avoid double-borrow issues.
+        // Route content based on final fd table.
         let orig_stdout = std::mem::take(&mut result.stdout);
         let orig_stderr = std::mem::take(&mut result.stderr);
+        let pending = std::mem::take(&mut self.pending_fd_output);
 
-        // Determine what goes where
         let mut new_stdout = String::new();
         let mut new_stderr = String::new();
-        // file_path -> (content, is_append, display_path)
-        let mut file_writes: std::collections::HashMap<PathBuf, (String, bool, String)> =
-            std::collections::HashMap::new();
-
-        for (data, fd_target) in [(&orig_stdout, &fd1), (&orig_stderr, &fd2)].iter() {
+        let mut file_writes: HashMap<PathBuf, (String, bool, String)> = HashMap::new();
+
+        // Route helper
+        let route = |data: &str,
+                     fd_target: &FdTarget,
+                     file_writes: &mut HashMap<PathBuf, (String, bool, String)>,
+                     new_stdout: &mut String,
+                     new_stderr: &mut String| {
             if data.is_empty() {
-                continue;
+                return;
             }
             match fd_target {
                 FdTarget::Stdout => new_stdout.push_str(data),
@@ -6068,6 +6082,36 @@ impl Interpreter {
                         .push_str(data);
                 }
             }
+        };
+
+        // Route fd1 (stdout) and fd2 (stderr)
+        let fd1_target = fd_table.get(&1).cloned().unwrap_or(FdTarget::Stdout);
+        let fd2_target = fd_table.get(&2).cloned().unwrap_or(FdTarget::Stderr);
+        route(
+            &orig_stdout,
+            &fd1_target,
+            &mut file_writes,
+            &mut new_stdout,
+            &mut new_stderr,
+        );
+        route(
+            &orig_stderr,
+            &fd2_target,
+            &mut file_writes,
+            &mut new_stdout,
+            &mut new_stderr,
+        );
+
+        // Route pending fd3+ output from inner `1>&3` redirects
+        for (fd_num, data) in &pending {
+            let target = fd_table.get(fd_num).cloned().unwrap_or(FdTarget::Stdout);
+            route(
+                &data,
+                &target,
+                &mut file_writes,
+                &mut new_stdout,
+                &mut new_stderr,
+            );
         }
 
         // Write files
@@ -10898,4 +10942,21 @@ echo "count=$COUNT"
         let result = run_script("shopt -s failglob; ls ./*.html 2>/dev/null; echo exit:$?").await;
         assert_eq!(result.stderr, "", "failglob: stderr should be suppressed");
     }
+
+    #[tokio::test]
+    async fn test_fd3_redirect_pattern() {
+        // Issue #1115: { echo "progress" 1>&3; echo "file content"; } 3>&1 >file
+        // fd3 captures original stdout before >file redirects fd1
+        let result = run_script(
+            r#"{ echo "progress" 1>&3; echo "file content"; } 3>&1 > /tmp/test_fd.txt
+cat /tmp/test_fd.txt"#,
+        )
+        .await;
+        let lines: Vec<&str> = result.stdout.lines().collect();
+        assert_eq!(
+            lines,
+            vec!["progress", "file content"],
+            "fd3 content should appear first on stdout, file content from cat second"
+        );
+    }
 }

crates/bashkit/tests/spec_cases/bash/exec-fd-redirect.test.sh

@@ -35,3 +35,12 @@ echo "closed ok"
 ### expect
 closed ok
 ### end
+
+### fd3_redirect_pattern
+# { cmd 1>&3; cmd; } 3>&1 >file — fd3 captures original stdout (issue #1115)
+{ echo "progress" 1>&3; echo "file content"; } 3>&1 > /tmp/test_fd.txt
+cat /tmp/test_fd.txt
+### expect
+progress
+file content
+### end