Struct ExecResult 

#[non_exhaustive]
pub struct ExecResult {
    pub code: i64,
    pub err: String,
    pub data: Option<Value>,
    pub did_spill: bool,
    pub original_code: Option<i64>,
    pub content_type: Option<String>,
    pub baggage: BTreeMap<String, String>,
    /* private fields */
}

The result of executing a command or pipeline.

$? in script syntax is the POSIX exit code (an integer). To read the previous command’s structured .data (or its captured stdout) from inside a script, use the kaish-last builtin and pipe / capture its output. Inside Rust callers, read .data, .text_out(), etc. directly.

Notes on the fields:

• code — exit code (0 = success)
• err — error message if failed
• out — raw stdout as string
• data — structured data; only set by builtins/tools that opt in (e.g. seq, jq, cut, find, glob, split). External commands never populate this — pipe their stdout through jq to get it.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

code: i64

Exit code. 0 means success.

err: String

Raw standard error as a string.

data: Option<Value>

Structured data — only populated when a builtin/tool sets it explicitly. Stdout is never sniffed; this stays None for external commands.

did_spill: bool

True if the output limiter capped this result. Either the overflow was written to a disk spill file (the out message carries the path) or it was truncated in memory (Memory spill mode — head+tail only, no recoverable file). Both cases remap the exit code to 3.

original_code: Option<i64>

The command’s original exit code before spill logic overwrote it with 2 or 3. Present only when did_spill is true and code was changed.

content_type: Option<String>

MIME content type hint (e.g., “text/markdown”, “image/svg+xml”). When set, downstream consumers can use this instead of sniffing content.

baggage: BTreeMap<String, String>

Opaque key-value context propagated from tools through execution. Intermediaries (kaish) carry but don’t interpret. Consumers read known keys. Follows W3C Baggage semantics — useful for OTel trace propagation, application-level hints, etc.

Implementations

impl ExecResult

pub fn success(out: impl Into<String>) -> ExecResult

Create a successful result with output.

pub fn with_output(output: OutputData) -> ExecResult

Create a successful result with structured output data.

The OutputData is the source of truth. Text is materialized lazily via text_out() when needed (pipes, redirects, command substitution).

pub fn success_data(data: Value) -> ExecResult

Create a successful result with structured data.

pub fn success_with_data(out: impl Into<String>, data: Value) -> ExecResult

Create a successful result with both text output and structured data.

Use this when a command should have:

• Text output for pipes and traditional shell usage
• Structured data for iteration and programmatic access

The data field takes precedence for command substitution in contexts like for i in $(cmd) where the structured data can be iterated.

pub fn failure(code: i64, err: impl Into<String>) -> ExecResult

Create a failed result with an error message.

pub fn from_output( code: i64, stdout: impl Into<String>, stderr: impl Into<String>, ) -> ExecResult

Create a result from raw output streams.

data is left empty — kaish does not sniff stdout for JSON. To get structured iteration from an external command, pipe through jq: for i in $(curl ... | jq .); do ....

pub fn with_output_and_text( output: OutputData, text: impl Into<String>, ) -> ExecResult

Create a successful result with structured output and explicit pipe text.

Use this when a builtin needs custom text formatting that differs from the canonical OutputData::to_canonical_string() representation.

pub fn from_parts( code: i64, out: String, err: String, data: Option<Value>, ) -> ExecResult

Create a result from parts — for kernel struct literal sites.

pub fn with_code(self, code: i64) -> ExecResult

Builder: set the exit code, returning self for chaining.

pub fn text_out(&self) -> Cow<'_, str>

Get text output, materializing from OutputData on demand.

Returns self.out if non-empty, otherwise falls back to OutputData::to_canonical_string(). This is the canonical way to get text for pipes, command substitution, and file redirects.

pub fn output(&self) -> Option<&OutputData>

Get a reference to structured output data.

pub fn has_output(&self) -> bool

True if structured output data is present.

pub fn set_out(&mut self, s: String)

Replace .out with a new string.

pub fn push_out(&mut self, s: &str)

Append to .out.

pub fn clear_out(&mut self)

Clear .out.

pub fn set_output(&mut self, o: Option<OutputData>)

Replace .output.

pub fn take_output(&mut self) -> Option<OutputData>

Take .output, leaving None.

pub fn materialize(&mut self)

Materialize: if .out is empty and .output is present, populate .out from canonical string and clear .output.

pub fn take_output_for_stream(&mut self) -> Option<OutputData>

Take .output only if .out is empty (no custom text), so caller can stream directly without materializing.

pub fn ok(&self) -> bool

True if the command succeeded (exit code 0).

pub fn with_content_type(self, ct: impl Into<String>) -> ExecResult

Set content type hint, returning self for chaining.

Trait Implementations

impl Clone for ExecResult

fn clone(&self) -> ExecResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExecResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ExecResult

fn default() -> ExecResult

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExecResult

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExecResult, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExecResult

fn eq(&self, other: &ExecResult) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExecResult

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExecResult