feat: add std/io and std/keyboard modules across 6 backends

[notactuallytreyanastasio]

Summary

Adds std/io (sleep, readLine) and std/keyboard (nextKeypress) modules to Temper's standard library, wired across all six backends (JS, Python, Lua, Rust, Java, C#).

These are the first I/O primitives in Temper that enable interactive, real-time programs without host-language wrappers. The snake game now works on all 6 backends using arrow keys and WASD, no Enter key required.

What changed since review

Addressed all of Mike's feedback:

1. readLine simplified — No longer does raw TTY / single-keypress reading. All 6 backends now do actual buffered line input. readLine() reads lines, period.
2. Process exits removed — Removed all System.exit, process.exit, os.kill, Environment.Exit calls from readLine. A library shouldn't terminate the host.
3. Java completeExceptionally — Fixed the swallowed exception bug.
4. C# net8.0 reverted — Back to net6.0. The version bump was incidental.
5. New std/keyboard module — Keypress input split into its own module (std/keyboard) with clean boundaries, separate from std/io. This addresses Mike's concern about scoping raw terminal access.
6. Windows support — 5/6 backends support Windows for keyboard input (Java via PowerShell, JS via Node setRawMode, Python via msvcrt, C# via Console.ReadKey, Rust via crossterm). Lua is Unix-only.

API

std/io

@connected("stdSleep")
export let sleep(ms: Int): Promise<Empty> { panic() }

@connected("stdReadLine")
export let readLine(): Promise<String?> { panic() }

std/keyboard

@connected("stdNextKeypress")
export let nextKeypress(): Promise<String?> { panic() }

Returns key names as strings: "a", "ArrowUp", "Enter", "Escape", etc. Returns null on EOF.

Architecture

The snake game uses two concurrent async blocks sharing mutable direction state:

let {nextKeypress} = import("std/keyboard");
let {sleep} = import("std/io");

var inputDirection: Direction = new Right();

// Input loop — runs on its own thread/coroutine
async { ... =>
  while (true) {
    let key = await nextKeypress();
    // update inputDirection
  }
}

// Game tick — runs concurrently
async { ... =>
  while (game.status is Playing) {
    game = changeDirection(game, inputDirection);
    game = tick(game);
    console.log(render(game));
    await sleep(200);
  }
}

readLine() stays library-safe (buffered, blocking, no terminal manipulation). nextKeypress() is the explicit opt-in for "I own the terminal" programs.

Per-Backend keyboard implementations

Backend	Unix	Windows
Java	stty raw + escape sequence parsing	PowerShell [Console]::ReadKey($true)
JS	process.stdin.setRawMode(true)	Same (Node handles it)
Python	tty.setraw() + termios	msvcrt.getwch()
Lua	stty raw via cooperative scheduler	Not supported (returns null)
C#	Console.ReadKey(true)	Same (cross-platform)
Rust	crossterm crate	Same (cross-platform)

Test plan

• controlFlowIoSleep functional test passes on all 6 backends
• JsRunFileLayoutTest.someModules passes (snapshots updated for io.js/keyboard.js)
• ReplTest.translateToLua passes (regex updated for scheduler call)
• Snake game plays with arrow keys + WASD on JS, Python, Lua, Rust, Java, C#
• Snake moves continuously on timer while waiting for keypress input

🤖 Generated with Claude Code

Co-Authored-By: Claude Opus 4.6 (1M context) noreply@anthropic.com

[ShawSumma]

If this were to be merged I'd want some things, specifically it being in std/ as you reach for names like stdSleep. I think a std/sys module would do better, as sleep isn't IO really.

[mikesamuel]

I like the use of Promise<Empty> to represent sleeping, and that you're doing it all in coroutine land.

[mikesamuel]

I think if you run gradle ktlintFormat, the CI/CD will be a lot happier.

[mikesamuel]

Temper is a language for libraries which should leave exiting up to the program.

[notactuallytreyanastasio]

Agreed — will remove all System.exit / process.exit / os.kill / Environment.Exit calls from readLine across every backend. A library has no business killing the host process.

[mikesamuel]

This defaults to the system encoding which might not be the same as the terminal encoding.

It also doesn't release the file handle.

If there's no System.console(), then I think maybe we just need to default to assuming that there's no input to read.

[notactuallytreyanastasio]

Noted — need to figure out the right encoding and resource handling here. Will flag this when we get to the readLine simplification so we don't just cargo-cult the same mistakes into the cleanup.

[mikesamuel]

@ShawSumma we forgot to actually implement async support in be-lua. Could you give some eyes to this.

[mikesamuel]

Overall, impressive what you managed to put together quickly.

I think we need a bit more clarity on exactly what readLine does and shouldn't do.

io.temper.md says

Read one line from standard input. Returns null on EOF.

But iiuc, your immediate use case needs interactive (before ENTER) keypress information.

Temper is a language for libraries, not whole programs, so we need to be careful to limit the scope of global changes like raw TTY access that might adversely affect the larger program.

Maybe splitting the problem into two APIs would allow for better scoping.
Some ideas under be-java around ways to do that.

[mikesamuel]

Ok. I see this is run on the executor, so not blocking the main thread.