A raw-output session over `running` with the default tuning (`PtySessionOptions.Default`).

A raw-output session over `running` with explicit tuning. ANSI/VT escape sequences remain in pattern matching, `Pending`, and `Transcript`; use `WithAnsiFiltering` to remove them.

Close the child's stdin without cancellation. Equivalent to `CloseStdinAsync(CancellationToken.None)`.

Close the child's stdin, so it sees end-of-file — how a conversation that feeds input ends for a child that reads until EOF. Idempotent; returns the same typed `Unsupported` as the send verbs when the run has no interactive stdin. A `Command.Stdin` source is awaited before closing so its bytes cannot be truncated by the interactive close. `cancellationToken` bounds only that pre-delivery wait; once stdin is claimed, end-of-input delivery is not cancellable. On a **PTY** there is no stdin pipe to close — input goes into the same terminal the conversation's output comes from — so the end of input is delivered as that terminal's own end-of-input gesture instead (see `ProcessStdin.FinishAsync`): on POSIX the pty's configured end-of-input character (`termios.c_cc[VEOF]`, Ctrl-D on a default terminal), on Windows the console's Ctrl-Z followed by Enter. The terminal itself stays open either way, so the child keeps its output — and, on Windows, its console session — for the rest of the run. Being a gesture the terminal interprets, it ends the input only of a child still reading in cooked mode (POSIX canonical mode, or a Windows console its own `CONIN$` mode has not switched to raw); one that reads its terminal raw receives those bytes as ordinary input, which is the terminal's contract rather than something this verb can paper over. A genuine failure to deliver it is a typed `Io` — never a silently dropped close that would leave the child waiting — while a child that has already closed its terminal is reported as the `Ok` it is: there is nothing left to tell it.

Wait until `pattern` matches somewhere in the child's terminal output — the regular-expression form of the overload above, with the identical timeout, consumption, early-end, and error contract. The `Regex` is used exactly as given, including its own options and `MatchTimeout`. Matching runs over the same sliding, unframed session view as the string overload, so `^`/`$` anchor against the window's bounds rather than the child's line structure unless you pass `RegexOptions.Multiline`. A zero-width match is rejected with a typed `Unsupported` result, because it cannot advance the session window.

Wait until `pattern` appears in the child's terminal output, or fail with `NotReady` after `timeout` — a budget for THIS pattern alone, entirely separate from the run-wide `Command.Timeout`/`IdleTimeout` (which kill the child; this one does not). `Cancelled` if `cancellationToken` fires first. The match is an ordinal substring search over the unframed session view (raw by default, control-free from `WithAnsiFiltering`), so a prompt that never ends its line (`Password: `) is found the moment it arrives. Note that a terminal ends its own lines with `\r\n`: match on the prompt text itself rather than on a trailing `\n`. Everything up to and including the match is consumed, so the next call starts after it; a pattern that has not arrived by the deadline leaves the window untouched, so a longer retry still sees what did arrive. `pattern` must be non-null; an empty pattern returns a typed `Unsupported` result because it cannot advance the session window. Ends promptly with `NotReady` if the child's output ends first (it exited, or closed the terminal) rather than waiting out the whole `timeout`, and with `ProcessError.Io` if reading it genuinely failed.

The output received but not yet consumed by a pattern — what the next `ExpectAsync` will match against. Reading it consumes nothing; it is for diagnosing a pattern that did not arrive ("what did the child actually print?") without having to keep a transcript.

Send `text` to the child exactly as given — no line ending appended — encoded with the command's terminal encoding (`Command.StdoutEncoding`, UTF-8 by default). Use it for a control character (U+0003 is Ctrl+C to a terminal) or to answer a prompt that reads a single keystroke rather than a line. On Windows ConPTY, U+0003 does not interrupt the child by default: ProcessKit's unconditional `CREATE_NEW_PROCESS_GROUP` isolation disables default CTRL+C handling. Returns a typed `Unsupported` when the run has no interactive stdin (build the command with `Command.KeepStdinOpen`), `Cancelled` if `cancellationToken` fires, and `Io` if the child has closed its input — never a silently dropped write. With `Command.Stdin(source)` plus `Command.KeepStdinOpen`, the source feeder is awaited here before the first interactive byte; construction itself does not wait for that source. As with any cancellable stream write, a cancelled send may already have delivered *some* of its bytes, so recover by abandoning the conversation rather than resending (which would duplicate the delivered prefix). Sent bytes are never logged, traced, or added to `Transcript`; a terminal with echo on will nevertheless reflect them back into the child's output (see the type-level secret-safety note).

Send `text` followed by the session's line ending (`PtySessionOptions.LineEnding`, by default a carriage return on a PTY run — what a terminal sends for Enter — and a line feed otherwise). The answer to a prompt. Same encoding, refusal, and secret-safety contract as `SendAsync`.

Everything the child has emitted this session, in order — empty when `CaptureTranscript` is off, and holding at most `TranscriptChars` characters (oldest dropped first, see `TranscriptTruncated`). Readable at any point, during the conversation as well as after it. Contains only the child's output; input sent through this session is never recorded here, though a terminal with echo on reflects it into the child's output anyway.

Whether the transcript has already dropped output to stay within `TranscriptChars` — so a diagnosis reading `Transcript` knows it is looking at the tail of the session, not all of it.

Wait for the child to exit and for this session's readers to finish draining its terminal, then report how it concluded. A non-zero or killed exit is data, not a raised error. Does **not** reap: dispose the `RunningProcess` (or its owning `ProcessGroup`) for that, exactly as after `OutputEventsAsync`. It shares this handle's one exit wait, so it never starts a second wait racing the session's own readers.

Whether the match window has already dropped output to stay within `WindowChars` — a pattern expecting context that far back can no longer match, and `ExpectMatch.Before` is correspondingly incomplete.

Create an ANSI-filtered session with the default tuning (`PtySessionOptions.Default`).

Create a session that removes ANSI/VT escape sequences before matching or retaining terminal output. Filtering is incremental across read boundaries and covers CSI sequences, OSC strings terminated by BEL or ST, and single ESC forms. Byte-exact output tees remain unfiltered.