* prompt that lands after an interruption is a prompt the user did not mean

   * to send.

   */

  async submit(prompt: string): Promise<void> {

  async submit(prompt: string, mode: "steer" | "queue" = "steer"): Promise<void> {

    if (prompt.trim().length === 0) return;

    // Delegation is not a turn: it does not go to the model, it does not block

    if (this.controller !== undefined) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      // Steering first: a source that runs a loop of model calls can read this

      // at its next step, so the model sees it while it is still working. A

      // source that cannot holds it until the turn ends instead of dropping it.

      if (this.source.steer?.(prompt) === true) {

      // Steering by default: a source that runs a loop of model calls reads

      // this at its next step, so the model sees it while it is still working.

      // A reader who wants the turn finished first asks for `queue`, and a

      // source that cannot steer holds it to the end either way.

      if (mode === "steer" && this.source.steer?.(prompt) === true) {

        this.notice("Steering: the model reads this at its next step.");

        this.emit();

        return;

 * alternate screen is up. It costs one escape sequence and, unlike mouse

 * reporting, leaves the terminal's own text selection alone.

 */

/**

 * Ask the terminal to report modified keys unambiguously.

 *

 * Flag 1 of the keyboard protocol — disambiguate escape codes. Without it

 * shift+enter arrives as the same carriage return as enter, and the two cannot

 * be told apart at all. Ordinary text is unaffected; only keys that were

 * already ambiguous change shape, and a terminal that does not implement this

 * ignores it, which leaves enter doing the default and costs nothing.

 */

const KEYS_DISAMBIGUATE_ON = "\x1b[>1u";

const KEYS_DISAMBIGUATE_OFF = "\x1b[<u";

const ALT_SCROLL_ON = "\x1b[?1007h";

const ALT_SCROLL_OFF = "\x1b[?1007l";

      stdout.off("resize", onResize);

      if (stdin.isTTY) stdin.setRawMode(false);

      stdin.pause();

      write(CURSOR_SHOW + ALT_SCROLL_OFF + ALT_SCREEN_OFF);

      write(CURSOR_SHOW + KEYS_DISAMBIGUATE_OFF + ALT_SCROLL_OFF + ALT_SCREEN_OFF);

      resolve(exitCode);

    };

      // interrupt" while idle, where there was nothing to interrupt.

      const keys: Hint[] = [];

      if (snapshot.running) {

        keys.push({ text: "esc to interrupt" }, { text: "ctrl+c to stop" });

        keys.push(

          { text: "enter to steer" },

          { text: "shift+enter to queue" },

          { text: "esc to interrupt" },

        );

      } else {

        keys.push({ text: "enter to send" });

        if (composer.length > 0) keys.push({ text: "esc to clear" });

      anchor = next >= maxStart ? undefined : next;

    };

    const submit = () => {

    const submit = (mode: "steer" | "queue" = "steer") => {

      const prompt = composer;

      composer = "";

      anchor = undefined;

        return;

      }

      void session.submit(prompt).finally(() => {

      void session.submit(prompt, mode).finally(() => {

        if (ticker !== undefined) {

          clearInterval(ticker);

          ticker = undefined;

            break;

          }

          index += sequence.length;

          // Before the bare escape is taken as an interrupt: some terminals

          // send escape then return for shift or alt enter, and an escape with

          // a return immediately behind it is not something a reader types by

          // accident.

          if (sequence === "\x1b" && text[index] === "\r") {

            index += 1;

            submit("queue");

            dirty = false;

            continue;

          }

          if (sequence === "\x1b") {

            onEscape();

            dirty = false;

            continue;

          }

          // Enter reported through the keyboard protocol: `13` is the key and

          // the second parameter is the modifier, where 2 is shift. Shift+enter

          // queues; enter, with or without other modifiers, steers.

          const enter = /^\x1b\[13(?:;(\d+))?u$/.exec(sequence);

          if (enter !== null) {

            if (!session.running || composer.length > 0) {

              submit(enter[1] === "2" ? "queue" : "steer");

            }

            dirty = false;

            continue;

          }

          const page = Math.max(1, viewport - 1);

          if (sequence === "\x1b[5~") scrollBy(-page);

          else if (sequence === "\x1b[6~") scrollBy(page);

    const unsubscribe = session.onChange(render);

    write(ALT_SCREEN_ON + ALT_SCROLL_ON);

    write(ALT_SCREEN_ON + ALT_SCROLL_ON + KEYS_DISAMBIGUATE_ON);

    if (stdin.isTTY) stdin.setRawMode(true);

    stdin.resume();

    stdin.setEncoding("utf8");

    await running;

  });

  it("steers on enter and queues on shift+enter", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const modes: string[] = [];

    const { source: paused, release } = held();

    const session = new CoderSession(paused, "repo", "main");

    const realSubmit = session.submit.bind(session);

    session.submit = (prompt: string, mode?: "steer" | "queue") => {

      modes.push(mode ?? "steer");

      return realSubmit(prompt, mode);

    };

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    const turn = session.submit("go");

    await new Promise((resolve) => setTimeout(resolve, 0));

    stdin.emit("data", "one");

    stdin.emit("data", "\r");

    // Shift+enter, as the keyboard protocol reports it: key 13, modifier 2.

    stdin.emit("data", "two");

    stdin.emit("data", "\x1b[13;2u");

    // And as the terminals that do not speak the protocol send it.

    stdin.emit("data", "three");

    stdin.emit("data", "\x1b\r");

    expect(modes).toEqual(["steer", "steer", "queue", "queue"]);

    release();

    await turn;

    stdin.emit("data", "\x04");

    await running;

  });

  it("asks the terminal to tell enter and shift+enter apart, and stops asking on the way out", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(source([]), "repo", "main");

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    // Without this they arrive as the same carriage return and cannot be told

    // apart at all.

    expect(stdout.written).toContain("\x1b[>1u");

    stdin.emit("data", "\x04");

    await running;

    // Left as it was found: a terminal still reporting this after the session

    // has gone is a terminal the next program has to cope with.

    expect(stdout.written).toContain("\x1b[<u");

  });

  it("queues ordinary text and sends it when the turn ends", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();