// Print without trailing newline — the no-newline sibling of print.ln.
// SAME implementation (__printInterpolate, with_newline=false): comptime
// {{ }} interpolation, rerouted to print.impl for shape checking.
//
// The old RUNTIME passthrough tor (`print { text }` + |zig/|js procs) died
// here (2026-06-11, Lars ruling: std/io's print surface is comptime-only;
// stage/runtime printing is the future std/compiler print-family). Its
// positional-arg mis-emit bug died with the codepath.
~[keyword|comptime|transform] pub tor print {
    expr: ?Expression,
    invocation: *const Invocation,
    item: std/compiler:*const Item,
    program: std/compiler:*const Program,
    reporter: std/compiler:*ErrorReporter,
    allocator: std.mem.Allocator
} -> SiteResult

// `println` REMOVED — subsumed by `print.ln` (the interpolating print). Calling
// `std/io:println` is now an unknown-event error by design (greenfield: the old
// form must fail loudly once removed).
//
// Print formatted text
// NOTE: printf with varargs would require runtime support — deliberately absent.
//
// One blocking line from stdin. EOF is a branch, not an empty string —
// an empty line is `line` with length 0. The buffer is module-static:
// the returned slice is valid until the next readln (the caller must
// finish with the line first). That is the interactive/pipe contract
// (`650_009`); read.ln remains the leaky slurp-a-chunk sibling.
~pub tor readln {}
| line string
| eof
| failed string

// Simple line reader - returns the line, or empty string on EOF/error
// No error handling, just returns what it gets
~pub tor read.ln {} -> string

// Print error to stderr
~pub tor eprintln { message: string<*@scoped> }

// Success message with green color (if terminal supports it)
~pub tor success { message: string<*@scoped> }

// Warning message
~pub tor warn { message: string<*@scoped> }

~[
- aspirational
  Same gap as std/fs:read-lines: a per-line streaming surface backed by a
  whole-stream slurp (readToEndAlloc), bounded by RAM. True streaming is the
  deferred honest fix; marked so the gap is explicit and greppable.
]pub tor read-lines {}
! line string
| done usize
| failed string

// Read entire stdin as text. The buffer is allocator-owned and carries the
// `allocated!` obligation: hand it to `std/io:free` (auto-discharge inserts
// the call when the trace is unambiguous — most callers never write it).
// Ruled 2026-07-31 (the 335_042/043 question): one label, `allocated`, for
// every allocator-owned buffer an io tor hands back; `std/io:free` is the
// one disposer.
~pub tor read-stdin {}
| ok string<allocated!>
| eof
| failed string

// Read entire file as text. `ok` carries the `allocated!` obligation — see
// read-stdin's header; `std/io:free` discharges it.
~pub tor read-file { path: string }
| ok string<allocated!>
| not-found
| failed string

// Discharge the `allocated!` obligation on a buffer an io tor handed back
// (read-file, read-stdin). The one disposer for the one label.
~pub tor free { content: string<!allocated> }

// Get command line arguments
~pub tor args {} -> []string

// PRINT.LN - Interpolated printing with Expression (ZERO OVERHEAD)
//
// Syntax: std/io:print.ln("Hello {{ name }}! Count: {{ count }}")
//
// ARCHITECTURE:
// - print.ln is a comptime transform that generates inline Zig code
// - Parses {{ ... }} placeholders from the Expression string
// - Optional format specifier: {{ name:s }} or {{ count:d }}
// - Generates: std.debug.print("Hello {}! Count: {}\n", .{name, count});
//
// This is NOT a regular tor - it's a pure compile-time transformation.
~[keyword|comptime|transform] pub tor print.ln {
    expr: ?Expression,
    invocation: *const Invocation,
    item: std/compiler:*const Item,
    program: std/compiler:*const Program,
    reporter: std/compiler:*ErrorReporter,
    allocator: std.mem.Allocator
} -> SiteResult

~[norun] pub tor print.impl { expr: string<*@scoped> }

// eprint / eprint.ln — the stderr siblings of print / print.ln. Same engine
// (__printInterpolate), routed to fd 2. They reuse print.impl for shape
// checking (the reroute is analysis-only; the inline body does the write).
~[keyword|comptime|transform] pub tor eprint.ln {
    expr: Expression,
    invocation: *const Invocation,
    item: std/compiler:*const Item,
    program: std/compiler:*const Program,
    reporter: std/compiler:*ErrorReporter,
    allocator: std.mem.Allocator
} -> SiteResult

~[keyword|comptime|transform] pub tor eprint {
    expr: Expression,
    invocation: *const Invocation,
    item: std/compiler:*const Item,
    program: std/compiler:*const Program,
    reporter: std/compiler:*ErrorReporter,
    allocator: std.mem.Allocator
} -> SiteResult

~[comptime|transform] pub tor print.blk {
    source: Source,
    invocation: *const Invocation,
    item: std/compiler:*const Item,
    program: std/compiler:*const Program,
    reporter: std/compiler:*ErrorReporter,
    allocator: std.mem.Allocator
} -> SiteResult

~[norun] pub tor print.blk.impl { text: string }