import { beforeAll, describe, expect, test } from "bun:test";

import { parse } from "./shell-parser.js";

// The parser lazily initializes web-tree-sitter on first call.
// All tests share the same parser instance.

describe("Shell Parser", () => {
  beforeAll(async () => {
    // Warm up the parser (loads WASM)
    await parse("echo warmup");
  });

  // ── Simple commands ──────────────────────────────────────────────

  describe("simple commands", () => {
    test("parses bare command: ls", async () => {
      const result = await parse("ls");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("ls");
      expect(result.segments[0].args).toEqual([]);
      expect(result.segments[0].operator).toBe("");
      expect(result.dangerousPatterns).toHaveLength(0);
      expect(result.hasOpaqueConstructs).toBe(false);
    });

    test("parses command with one arg: cat foo.txt", async () => {
      const result = await parse("cat foo.txt");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("cat");
      expect(result.segments[0].args).toEqual(["foo.txt"]);
      expect(result.dangerousPatterns).toHaveLength(0);
      expect(result.hasOpaqueConstructs).toBe(false);
    });

    test("parses command with multiple args", async () => {
      const result = await parse("echo hello world");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("echo");
      expect(result.segments[0].args).toEqual(["hello", "world"]);
    });

    test("parses command with flags", async () => {
      const result = await parse("ls -la /tmp");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("ls");
      expect(result.segments[0].args).toContain("-la");
      expect(result.segments[0].args).toContain("/tmp");
    });

    test("parses quoted arguments", async () => {
      const result = await parse('grep "hello world" file.txt');
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("grep");
    });
  });

  // ── Compound commands ────────────────────────────────────────────

  describe("compound commands", () => {
    test("parses && operator", async () => {
      const result = await parse("echo hello && rm file");
      expect(result.segments).toHaveLength(2);
      expect(result.segments[0].program).toBe("echo");
      expect(result.segments[0].operator).toBe("");
      expect(result.segments[1].program).toBe("rm");
      expect(result.segments[1].operator).toBe("&&");
    });

    test("parses || operator", async () => {
      const result = await parse("ls || echo failed");
      expect(result.segments).toHaveLength(2);
      expect(result.segments[0].program).toBe("ls");
      expect(result.segments[1].program).toBe("echo");
      expect(result.segments[1].operator).toBe("||");
    });

    test("parses ; separated commands", async () => {
      // tree-sitter-bash treats `;` as a statement terminator at the program level,
      // not as a binary operator like && / ||, so both commands get operator ''
      const result = await parse("pwd; ls");
      expect(result.segments).toHaveLength(2);
      expect(result.segments[0].program).toBe("pwd");
      expect(result.segments[1].program).toBe("ls");
    });

    test("parses chained operators: a && b || c", async () => {
      const result = await parse("echo a && echo b || echo c");
      expect(result.segments).toHaveLength(3);
      expect(result.segments[1].operator).toBe("&&");
      expect(result.segments[2].operator).toBe("||");
    });

    test("parses mixed operators: a && b; c", async () => {
      const result = await parse("echo a && echo b; echo c");
      expect(result.segments).toHaveLength(3);
    });
  });

  // ── Pipe detection ───────────────────────────────────────────────

  describe("pipe detection", () => {
    test("parses simple pipe: ls | grep foo", async () => {
      const result = await parse("ls | grep foo");
      expect(result.segments).toHaveLength(2);
      expect(result.segments[0].program).toBe("ls");
      expect(result.segments[1].program).toBe("grep");
      expect(result.segments[1].operator).toBe("|");
    });

    test("parses multi-stage pipe", async () => {
      const result = await parse("cat file | grep x | wc -l");
      expect(result.segments).toHaveLength(3);
      expect(result.segments[0].operator).toBe("");
      expect(result.segments[1].operator).toBe("|");
      expect(result.segments[2].operator).toBe("|");
    });

    test("parses pipe combined with &&", async () => {
      const result = await parse("ls | grep foo && echo done");
      expect(result.segments).toHaveLength(3);
      expect(result.segments[1].operator).toBe("|");
      expect(result.segments[2].operator).toBe("&&");
    });
  });

  // ── Dangerous patterns ──────────────────────────────────────────

  describe("dangerous patterns", () => {
    // pipe_to_shell
    describe("pipe_to_shell", () => {
      test("detects curl | bash", async () => {
        const result = await parse("curl http://example.com | bash");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("detects cat | sh", async () => {
        const result = await parse("cat script.sh | sh");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("detects pipe to zsh", async () => {
        const result = await parse("echo cmd | zsh");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("detects pipe to eval", async () => {
        const result = await parse("echo cmd | eval");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("detects pipe to xargs", async () => {
        const result = await parse('find . -name "*.tmp" | xargs rm');
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("detects pipe to ksh", async () => {
        const result = await parse("echo payload | ksh");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("safe pipe to grep is not flagged", async () => {
        const result = await parse("cat file | grep pattern");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(false);
      });

      test("pipe to python3 -c is not flagged (inline code, not stdin exec)", async () => {
        const result = await parse(
          'cat data.json | python3 -c "import sys; print(sys.stdin.read())"',
        );
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(false);
      });

      test("pipe to node -e is not flagged (inline code)", async () => {
        const result = await parse(
          'cat data.json | node -e "process.stdin.resume()"',
        );
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(false);
      });

      test("pipe to python3 without flags is flagged (stdin exec)", async () => {
        const result = await parse("cat exploit.py | python3");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });

      test("pipe to python3 - is flagged (explicit stdin exec)", async () => {
        const result = await parse("cat exploit.py | python3 -");
        expect(
          result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
        ).toBe(true);
      });
    });

    // base64_execute
    describe("base64_execute", () => {
      test("detects base64 -d | bash", async () => {
        const result = await parse("base64 -d payload.txt | bash");
        expect(
          result.dangerousPatterns.some((p) => p.type === "base64_execute"),
        ).toBe(true);
      });

      test("detects base64 -d | sh", async () => {
        const result = await parse("base64 -d input | sh");
        expect(
          result.dangerousPatterns.some((p) => p.type === "base64_execute"),
        ).toBe(true);
      });

      test("detects base64 -d | eval", async () => {
        const result = await parse("base64 -d data | eval");
        expect(
          result.dangerousPatterns.some((p) => p.type === "base64_execute"),
        ).toBe(true);
      });

      test("base64 without -d is not flagged as base64_execute", async () => {
        const result = await parse("base64 file | bash");
        // Still pipe_to_shell, but not base64_execute (no -d flag)
        expect(
          result.dangerousPatterns.some((p) => p.type === "base64_execute"),
        ).toBe(false);
      });
    });

    // process_substitution
    describe("process_substitution", () => {
      test("detects <() process substitution", async () => {
        const result = await parse("diff <(cmd1) <(cmd2)");
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "process_substitution",
          ),
        ).toBe(true);
      });

      test("detects single process substitution", async () => {
        const result = await parse("cat <(echo hello)");
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "process_substitution",
          ),
        ).toBe(true);
      });
    });

    // sensitive_redirect
    describe("sensitive_redirect", () => {
      test("detects redirect to ~/.ssh/", async () => {
        const result = await parse("echo key > ~/.ssh/authorized_keys");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to /etc/", async () => {
        const result = await parse("echo data > /etc/passwd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects append redirect to ~/.bashrc", async () => {
        const result = await parse('echo "alias x=y" >> ~/.bashrc');
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to ~/.zshrc", async () => {
        const result = await parse('echo "export FOO=bar" > ~/.zshrc');
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to ~/.gnupg/", async () => {
        const result = await parse("echo data > ~/.gnupg/gpg.conf");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to ~/.config/", async () => {
        const result = await parse("echo data > ~/.config/something");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to /usr/bin/", async () => {
        const result = await parse("echo data > /usr/bin/evil");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("detects redirect to /usr/lib/", async () => {
        const result = await parse("echo data > /usr/lib/evil.so");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(true);
      });

      test("redirect to regular file is not flagged", async () => {
        const result = await parse("echo data > output.txt");
        expect(
          result.dangerousPatterns.some((p) => p.type === "sensitive_redirect"),
        ).toBe(false);
      });
    });

    // dangerous_substitution
    describe("dangerous_substitution", () => {
      test("detects command substitution in rm", async () => {
        const result = await parse('rm $(find . -name "*.tmp")');
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "dangerous_substitution",
          ),
        ).toBe(true);
      });

      test("detects command substitution in chmod", async () => {
        const result = await parse("chmod $(echo 777) file");
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "dangerous_substitution",
          ),
        ).toBe(true);
      });

      test("detects command substitution in chown", async () => {
        const result = await parse("chown $(whoami) file");
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "dangerous_substitution",
          ),
        ).toBe(true);
      });

      test("command substitution in safe command is not flagged", async () => {
        const result = await parse("echo $(date)");
        expect(
          result.dangerousPatterns.some(
            (p) => p.type === "dangerous_substitution",
          ),
        ).toBe(false);
      });
    });

    // env_injection
    describe("env_injection", () => {
      test("detects LD_PRELOAD assignment", async () => {
        const result = await parse("LD_PRELOAD=evil.so cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects PATH modification", async () => {
        const result = await parse("PATH=/tmp cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects NODE_OPTIONS injection", async () => {
        const result = await parse('NODE_OPTIONS="--require evil" node app.js');
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects DYLD_INSERT_LIBRARIES", async () => {
        const result = await parse("DYLD_INSERT_LIBRARIES=evil.dylib cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects PYTHONPATH manipulation", async () => {
        const result = await parse("PYTHONPATH=/evil python script.py");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects LD_LIBRARY_PATH", async () => {
        const result = await parse("LD_LIBRARY_PATH=/evil cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects NODE_PATH", async () => {
        const result = await parse("NODE_PATH=/evil node");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects RUBYLIB", async () => {
        const result = await parse("RUBYLIB=/evil ruby");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects DYLD_LIBRARY_PATH", async () => {
        const result = await parse("DYLD_LIBRARY_PATH=/evil cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("detects DYLD_FRAMEWORK_PATH", async () => {
        const result = await parse("DYLD_FRAMEWORK_PATH=/evil cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(true);
      });

      test("safe env var is not flagged", async () => {
        const result = await parse("FOO=bar cmd");
        expect(
          result.dangerousPatterns.some((p) => p.type === "env_injection"),
        ).toBe(false);
      });
    });

    // No false positives on safe commands
    describe("no false positives", () => {
      test("simple ls has no dangerous patterns", async () => {
        const result = await parse("ls -la");
        expect(result.dangerousPatterns).toHaveLength(0);
      });

      test("git status has no dangerous patterns", async () => {
        const result = await parse("git status");
        expect(result.dangerousPatterns).toHaveLength(0);
      });

      test("safe pipe has no dangerous patterns", async () => {
        const result = await parse("cat file | grep pattern | wc -l");
        expect(result.dangerousPatterns).toHaveLength(0);
      });

      test("redirect to normal file has no dangerous patterns", async () => {
        const result = await parse("echo data > output.txt");
        expect(result.dangerousPatterns).toHaveLength(0);
      });
    });
  });

  // ── Opaque constructs ───────────────────────────────────────────

  describe("opaque constructs", () => {
    test("detects eval", async () => {
      const result = await parse('eval "ls -la"');
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects source", async () => {
      const result = await parse("source script.sh");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects dot command (.)", async () => {
      const result = await parse(". script.sh");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects bash -c", async () => {
      const result = await parse('bash -c "echo hello"');
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects sh -c", async () => {
      const result = await parse('sh -c "ls"');
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects zsh -c", async () => {
      const result = await parse('zsh -c "echo test"');
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects dash -c", async () => {
      const result = await parse('dash -c "echo test"');
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("detects heredoc", async () => {
      const result = await parse("cat <<EOF\nhello\nEOF");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("variable expansion as command name ($CMD) is opaque", async () => {
      const result = await parse("$CMD arg1 arg2");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("${var} expansion as command name is opaque", async () => {
      const result = await parse("${CMD} arg1");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("command substitution as command name is opaque", async () => {
      const result = await parse("$(get_cmd) arg1");
      expect(result.hasOpaqueConstructs).toBe(true);
    });

    test("safe command is NOT opaque", async () => {
      const result = await parse("ls -la");
      expect(result.hasOpaqueConstructs).toBe(false);
    });

    test("safe pipe is NOT opaque", async () => {
      const result = await parse("cat file | grep pattern");
      expect(result.hasOpaqueConstructs).toBe(false);
    });

    test("compound safe commands are NOT opaque", async () => {
      const result = await parse("echo hello && ls");
      expect(result.hasOpaqueConstructs).toBe(false);
    });

    test("git commit is NOT opaque", async () => {
      const result = await parse('git commit -m "fix bug"');
      expect(result.hasOpaqueConstructs).toBe(false);
    });
  });

  // ── Edge cases ──────────────────────────────────────────────────

  describe("edge cases", () => {
    test("handles empty command", async () => {
      const result = await parse("");
      expect(result.segments).toHaveLength(0);
      expect(result.dangerousPatterns).toHaveLength(0);
    });

    test("handles whitespace-only command", async () => {
      const result = await parse("   ");
      expect(result.segments).toHaveLength(0);
    });

    test("handles command with redirect", async () => {
      const result = await parse("echo hello > output.txt");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].program).toBe("echo");
    });

    test("handles long pipeline", async () => {
      const result = await parse("cat file | sort | uniq | head -10");
      expect(result.segments).toHaveLength(4);
      expect(result.segments[0].program).toBe("cat");
      expect(result.segments[1].program).toBe("sort");
      expect(result.segments[2].program).toBe("uniq");
      expect(result.segments[3].program).toBe("head");
    });

    test("combined dangerous: base64 decode piped to bash detects both patterns", async () => {
      const result = await parse("base64 -d payload | bash");
      // Should detect both base64_execute and pipe_to_shell
      expect(
        result.dangerousPatterns.some((p) => p.type === "base64_execute"),
      ).toBe(true);
      expect(
        result.dangerousPatterns.some((p) => p.type === "pipe_to_shell"),
      ).toBe(true);
    });
  });

  // ── originalCommand & synthetic flag ─────────────────────────────

  describe("originalCommand", () => {
    test("preserves the literal input verbatim for simple command", async () => {
      const result = await parse("ls -la /tmp");
      expect(result.originalCommand).toBe("ls -la /tmp");
    });

    test("preserves separator characters that segment reconstruction loses", async () => {
      // `;` and newlines are dropped by the segment walker — originalCommand
      // is the only place to recover the exact text the user typed.
      const result = await parse("ls; rm -rf /tmp/foo");
      expect(result.originalCommand).toBe("ls; rm -rf /tmp/foo");
    });

    test("preserves text for unparseable commands", async () => {
      const cmd = "cat /a/(b)/c.txt";
      const result = await parse(cmd);
      expect(result.originalCommand).toBe(cmd);
    });
  });

  describe("synthetic segment flag", () => {
    test("legitimate pipeline siblings are NOT synthetic", async () => {
      const result = await parse("ls -la | grep foo");
      expect(result.segments).toHaveLength(2);
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });

    test("legitimate `;`-separated siblings are NOT synthetic", async () => {
      const result = await parse("ls; rm -rf /tmp/foo");
      expect(result.segments).toHaveLength(2);
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });

    test("legitimate newline-separated siblings are NOT synthetic", async () => {
      const result = await parse("ls\nrm -rf /tmp/foo");
      expect(result.segments).toHaveLength(2);
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });

    test("legitimate `&&`-joined commands are NOT synthetic", async () => {
      const result = await parse("ls && pwd");
      expect(result.segments).toHaveLength(2);
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });

    test("legitimate `||`-joined commands are NOT synthetic", async () => {
      const result = await parse("ls || pwd");
      expect(result.segments).toHaveLength(2);
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });

    test("subshell segments ARE synthetic", async () => {
      // (cd /tmp && ls) — intentional grouping. Inner segments come from
      // a nested execution context, so consumers that show wildcard
      // suggestions to the user should not surface them as top-level.
      const result = await parse("(cd /tmp && ls)");
      expect(result.segments.length).toBeGreaterThan(0);
      expect(result.segments.every((s) => s.synthetic === true)).toBe(true);
    });

    test("if-statement body segments ARE synthetic", async () => {
      const result = await parse("if true; then rm -rf /; fi");
      expect(result.segments.length).toBeGreaterThan(0);
      expect(result.segments.every((s) => s.synthetic === true)).toBe(true);
    });

    test("while-loop body segments ARE synthetic", async () => {
      const result = await parse("while true; do echo hi; done");
      expect(result.segments.length).toBeGreaterThan(0);
      expect(result.segments.every((s) => s.synthetic === true)).toBe(true);
    });

    test("parse-recovery: unquoted parens in path mark ALL siblings synthetic", async () => {
      // The canonical bug: `(...)` in a path argument makes tree-sitter
      // split into multiple top-level statements with no separator.
      const result = await parse("cat /a/(b)/c.txt");
      expect(result.segments.length).toBeGreaterThan(1);
      // Every fragment — including the first `cat /a/` piece — must be
      // synthetic, because none of them represents a command the user
      // independently typed.
      expect(result.segments.every((s) => s.synthetic === true)).toBe(true);
    });

    test("parse-recovery in multi-stage pipeline marks ALL siblings synthetic", async () => {
      // The original bug repro from the iPhone screenshot.
      const cmd =
        "cat /workspace/vellum-assistant-platform/web/src/app/(app)/admin/organizations/[id]/page.tsx | grep -A 30 -B 5 \"credit\\|Credit\" | head -80";
      const result = await parse(cmd);
      expect(result.segments.length).toBeGreaterThan(1);
      expect(result.segments.every((s) => s.synthetic === true)).toBe(true);
      // The fragment programs the parser invented (e.g. `app`,
      // `/admin/organizations/[id]/page.tsx`) should never be surfaced as
      // independent top-level commands.
      const programs = result.segments.map((s) => s.program);
      expect(programs).toContain("app");
      expect(programs).toContain("/admin/organizations/[id]/page.tsx");
    });

    test("brackets in path do NOT trigger parse-recovery", async () => {
      // tree-sitter handles unquoted brackets in paths cleanly — only
      // parens cause the recovery split that motivated the synthetic flag.
      const result = await parse("cat /a/[b]/c");
      expect(result.segments).toHaveLength(1);
      expect(result.segments[0].synthetic).toBeFalsy();
    });

    test("dangerous command inside a subshell is still classified as dangerous", async () => {
      // Regression check: marking subshell segments synthetic must NOT
      // hide them from risk classification — `(rm -rf /)` is still high.
      const result = await parse("(rm -rf /)");
      expect(result.segments.length).toBeGreaterThan(0);
      const rmSeg = result.segments.find((s) => s.program === "rm");
      expect(rmSeg).toBeDefined();
      expect(rmSeg!.synthetic).toBe(true);
      expect(rmSeg!.args).toEqual(["-rf", "/"]);
    });

    test("non-ASCII text before a separator does not trigger spurious recovery", async () => {
      // Regression: tree-sitter byte offsets vs. JS UTF-16 code units.
      // For `echo café; ls`, the `é` is 2 bytes in UTF-8 but 1 code
      // unit in JS — using `source.slice(byteStart, byteEnd)` shifts
      // the gap window and misses the `;`, marking both siblings as
      // synthetic.
      const result = await parse("echo café; ls");
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
      const programs = result.segments.map((s) => s.program);
      expect(programs).toEqual(["echo", "ls"]);
    });

    test("multi-byte emoji before a separator does not trigger spurious recovery", async () => {
      // 🎉 is 4 bytes in UTF-8 (and 2 UTF-16 code units), exercising
      // the surrogate-pair branch of the byte-vs-code-unit fix.
      const result = await parse("echo 🎉; pwd");
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
      const programs = result.segments.map((s) => s.program);
      expect(programs).toEqual(["echo", "pwd"]);
    });

    test("`! cmd` does NOT mark the inner command synthetic", async () => {
      // `negated_command` is a prefix operator on a pipeline, not a
      // nested execution context. The user typed `ls` at the top level;
      // it must retain its `ls *` wildcard scope option.
      const result = await parse("! ls foo");
      const lsSeg = result.segments.find((s) => s.program === "ls");
      expect(lsSeg).toBeDefined();
      expect(lsSeg!.synthetic).toBeFalsy();
    });

    test("`! pipeline` keeps every segment non-synthetic", async () => {
      const result = await parse("! ls | grep foo");
      const programs = result.segments.map((s) => s.program);
      expect(programs).toContain("ls");
      expect(programs).toContain("grep");
      expect(result.segments.every((s) => !s.synthetic)).toBe(true);
    });
  });
});