runmat_runtime/builtins/io/

input.rs

//! MATLAB-compatible `input` builtin for line-oriented console interaction.

use runmat_builtins::{
    BuiltinCompletionPolicy, BuiltinDescriptor, BuiltinErrorDescriptor, BuiltinOutputMode,
    BuiltinParamArity, BuiltinParamDescriptor, BuiltinParamType, BuiltinSignatureDescriptor,
};
use runmat_builtins::{
    BuiltinExtensionDescriptor, BuiltinExtensionMode, BuiltinIntegerAuditDescriptor,
    BuiltinIntegerAuditKind,
};
use runmat_macros::runtime_builtin;
use runmat_value::{CharArray, LogicalArray, Tensor, Value};

use crate::builtins::common::spec::{
    BroadcastSemantics, BuiltinFusionSpec, BuiltinGpuSpec, ConstantStrategy, GpuOpKind,
    ReductionNaN, ResidencyPolicy, ShapeRequirements,
};
use crate::interaction;
use crate::{
    build_runtime_error, call_builtin_async, gather_if_needed_async, BuiltinResult, RuntimeError,
};

const DEFAULT_PROMPT: &str = "Input: ";
const BUILTIN_NAME: &str = "input";

const INPUT_NO_PROMPT_EXTENSION: BuiltinExtensionDescriptor = BuiltinExtensionDescriptor {
    id: "input-no-prompt",
    mode: BuiltinExtensionMode::RunMatOnly,
    description: "input() with RunMat's default prompt is a RunMat extension",
    error_identifier: Some("RunMat:compatibility:InputNoPromptExtension"),
};
const INPUT_SWAPPED_ARGUMENTS_EXTENSION: BuiltinExtensionDescriptor = BuiltinExtensionDescriptor {
    id: "input-swapped-arguments",
    mode: BuiltinExtensionMode::RunMatOnly,
    description: "input('s', prompt) argument order is a RunMat extension",
    error_identifier: Some("RunMat:compatibility:InputSwappedArgumentsExtension"),
};
pub const INPUT_EXTENSIONS: [BuiltinExtensionDescriptor; 2] =
    [INPUT_NO_PROMPT_EXTENSION, INPUT_SWAPPED_ARGUMENTS_EXTENSION];
pub const INPUT_INTEGER_AUDIT: BuiltinIntegerAuditDescriptor = BuiltinIntegerAuditDescriptor {
    kind: BuiltinIntegerAuditKind::NotApplicable,
    canonical_builtin: None,
    notes: "input accepts only a text prompt and the text flag 's'. In expression mode the entered expression is evaluated normally, so any integer result retains the class and shape produced by that expression rather than serving as an integer input role of input itself.",
};

const INPUT_OUTPUT: [BuiltinParamDescriptor; 1] = [BuiltinParamDescriptor {
    name: "value",
    ty: BuiltinParamType::Any,
    arity: BuiltinParamArity::Required,
    default: None,
    description: "Parsed scalar/matrix value, or raw text when using string mode.",
}];
const INPUT_INPUTS_NONE: [BuiltinParamDescriptor; 0] = [];
const INPUT_INPUTS_PROMPT: [BuiltinParamDescriptor; 1] = [BuiltinParamDescriptor {
    name: "prompt",
    ty: BuiltinParamType::Any,
    arity: BuiltinParamArity::Required,
    default: None,
    description: "Prompt text shown to the user.",
}];
const INPUT_INPUTS_PROMPT_FLAG: [BuiltinParamDescriptor; 2] = [
    BuiltinParamDescriptor {
        name: "prompt",
        ty: BuiltinParamType::Any,
        arity: BuiltinParamArity::Required,
        default: None,
        description: "Prompt text shown to the user.",
    },
    BuiltinParamDescriptor {
        name: "stringFlag",
        ty: BuiltinParamType::StringScalar,
        arity: BuiltinParamArity::Required,
        default: None,
        description: "Set to 's' to return the raw input text.",
    },
];
const INPUT_INPUTS_FLAG_PROMPT: [BuiltinParamDescriptor; 2] = [
    BuiltinParamDescriptor {
        name: "stringFlag",
        ty: BuiltinParamType::StringScalar,
        arity: BuiltinParamArity::Required,
        default: None,
        description: "Set to 's' to return the raw input text.",
    },
    BuiltinParamDescriptor {
        name: "prompt",
        ty: BuiltinParamType::Any,
        arity: BuiltinParamArity::Required,
        default: None,
        description: "Prompt text shown to the user.",
    },
];
const INPUT_SIGNATURES: [BuiltinSignatureDescriptor; 4] = [
    BuiltinSignatureDescriptor {
        label: "value = input()",
        inputs: &INPUT_INPUTS_NONE,
        outputs: &INPUT_OUTPUT,
    },
    BuiltinSignatureDescriptor {
        label: "value = input(prompt)",
        inputs: &INPUT_INPUTS_PROMPT,
        outputs: &INPUT_OUTPUT,
    },
    BuiltinSignatureDescriptor {
        label: "value = input(prompt, stringFlag)",
        inputs: &INPUT_INPUTS_PROMPT_FLAG,
        outputs: &INPUT_OUTPUT,
    },
    BuiltinSignatureDescriptor {
        label: "value = input(stringFlag, prompt)",
        inputs: &INPUT_INPUTS_FLAG_PROMPT,
        outputs: &INPUT_OUTPUT,
    },
];
const INPUT_ERROR_TOO_MANY_INPUTS: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.TOO_MANY_INPUTS",
    identifier: Some("RunMat:input:TooManyInputs"),
    when: "More than two input arguments are passed to input.",
    message: "input: too many inputs",
};
const INPUT_ERROR_INVALID_STRING_FLAG: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.INVALID_STRING_FLAG",
    identifier: Some("RunMat:input:InvalidStringFlag"),
    when: "The string mode flag is not a scalar string/char 's'.",
    message: "input: invalid string flag",
};
const INPUT_ERROR_PROMPT_ROW_VECTOR: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.PROMPT_ROW_VECTOR",
    identifier: Some("RunMat:input:PromptMustBeRowVector"),
    when: "Prompt char array is not 1-by-N.",
    message: "input: prompt must be a row vector",
};
const INPUT_ERROR_PROMPT_SCALAR_STRING: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.PROMPT_SCALAR_STRING",
    identifier: Some("RunMat:input:PromptMustBeScalarString"),
    when: "Prompt string array is not scalar.",
    message: "input: prompt must be a scalar string",
};
const INPUT_ERROR_INVALID_PROMPT_TYPE: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.INVALID_PROMPT_TYPE",
    identifier: Some("RunMat:input:InvalidPromptType"),
    when: "Prompt is not a string scalar or row char vector.",
    message: "input: invalid prompt type",
};
const INPUT_ERROR_INTERACTION_FAILED: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.INTERACTION_FAILED",
    identifier: Some("RunMat:input:InteractionFailed"),
    when: "Interactive prompt callback fails.",
    message: "input: interaction failed",
};
const INPUT_ERROR_EVAL_FAILED: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.EVAL_FAILED",
    identifier: Some("RunMat:input:EvalFailed"),
    when: "Expression evaluation hook rejects the input expression.",
    message: "input: invalid expression",
};
const INPUT_ERROR_INVALID_NUMERIC_EXPRESSION: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
    code: "RM.INPUT.INVALID_NUMERIC_EXPRESSION",
    identifier: Some("RunMat:input:InvalidNumericExpression"),
    when: "Numeric fallback parser rejects the input expression.",
    message: "input: invalid numeric expression",
};
const INPUT_ERRORS: [BuiltinErrorDescriptor; 8] = [
    INPUT_ERROR_TOO_MANY_INPUTS,
    INPUT_ERROR_INVALID_STRING_FLAG,
    INPUT_ERROR_PROMPT_ROW_VECTOR,
    INPUT_ERROR_PROMPT_SCALAR_STRING,
    INPUT_ERROR_INVALID_PROMPT_TYPE,
    INPUT_ERROR_INTERACTION_FAILED,
    INPUT_ERROR_EVAL_FAILED,
    INPUT_ERROR_INVALID_NUMERIC_EXPRESSION,
];
pub const INPUT_DESCRIPTOR: BuiltinDescriptor = BuiltinDescriptor {
    signatures: &INPUT_SIGNATURES,
    output_mode: BuiltinOutputMode::Fixed,
    completion_policy: BuiltinCompletionPolicy::Public,
    errors: &INPUT_ERRORS,
};

fn input_error(error: &'static BuiltinErrorDescriptor) -> RuntimeError {
    input_error_with(error, error.message)
}

fn input_error_with(
    error: &'static BuiltinErrorDescriptor,
    message: impl Into<String>,
) -> RuntimeError {
    let mut builder = build_runtime_error(message).with_builtin(BUILTIN_NAME);
    if let Some(identifier) = error.identifier {
        builder = builder.with_identifier(identifier.to_string());
    }
    builder.build()
}

fn input_error_with_source(
    error: &'static BuiltinErrorDescriptor,
    message: impl Into<String>,
    source: RuntimeError,
) -> RuntimeError {
    let mut builder = build_runtime_error(message)
        .with_builtin(BUILTIN_NAME)
        .with_source(source);
    if let Some(identifier) = error.identifier {
        builder = builder.with_identifier(identifier.to_string());
    }
    builder.build()
}

#[runmat_macros::register_gpu_spec(builtin_path = "crate::builtins::io::input")]
pub const GPU_SPEC: BuiltinGpuSpec = BuiltinGpuSpec {
    name: "input",
    op_kind: GpuOpKind::Custom("interaction"),
    supported_precisions: &[],
    broadcast: BroadcastSemantics::None,
    provider_hooks: &[],
    constant_strategy: ConstantStrategy::InlineLiteral,
    residency: ResidencyPolicy::GatherImmediately,
    nan_mode: ReductionNaN::Include,
    two_pass_threshold: None,
    workgroup_size: None,
    accepts_nan_mode: false,
    notes: "Prompts execute on the host. Interactive resident prompt and flag values are rejected before provider access; expression results retain the residency established by the entered expression itself.",
};

#[runmat_macros::register_fusion_spec(builtin_path = "crate::builtins::io::input")]
pub const FUSION_SPEC: BuiltinFusionSpec = BuiltinFusionSpec {
    name: "input",
    shape: ShapeRequirements::Any,
    constant_strategy: ConstantStrategy::InlineLiteral,
    elementwise: None,
    reduction: None,
    emits_nan: false,
    notes: "Side-effecting builtin; excluded from fusion plans.",
};

#[runtime_builtin(
    name = "input",
    summary = "Prompt users for interactive input.",
    extensions(INPUT_EXTENSIONS),
    integer_audit(crate::builtins::io::input::INPUT_INTEGER_AUDIT),
    type_resolver(crate::builtins::io::type_resolvers::input_type),
    descriptor(crate::builtins::io::input::INPUT_DESCRIPTOR),
    builtin_path = "crate::builtins::io::input"
)]
async fn input_builtin(args: Vec<Value>) -> BuiltinResult<Value> {
    if args.len() > 2 {
        return Err(input_error(&INPUT_ERROR_TOO_MANY_INPUTS));
    }

    if args.is_empty() {
        crate::compatibility::ensure_builtin_extension_enabled(
            &INPUT_NO_PROMPT_EXTENSION,
            BUILTIN_NAME,
        )?;
    }
    if args.iter().any(crate::dispatcher::value_contains_gpu) {
        return Err(input_error(&INPUT_ERROR_INVALID_PROMPT_TYPE));
    }

    let mut prompt_index = if args.is_empty() { None } else { Some(0usize) };
    let mut parsed_flag: Option<bool> = None;

    if let Some(idx) = if args.len() == 2 { Some(1usize) } else { None } {
        match parse_string_flag(&args[idx]).await {
            Ok(flag) => parsed_flag = Some(flag),
            Err(original_err) => {
                if let Some(prompt_idx) = prompt_index {
                    match parse_string_flag(&args[prompt_idx]).await {
                        Ok(swapped_flag) => {
                            crate::compatibility::ensure_builtin_extension_enabled(
                                &INPUT_SWAPPED_ARGUMENTS_EXTENSION,
                                BUILTIN_NAME,
                            )?;
                            parsed_flag = Some(swapped_flag);
                            prompt_index = Some(idx);
                        }
                        Err(_) => {
                            return Err(original_err);
                        }
                    }
                } else {
                    return Err(original_err);
                }
            }
        }
    }

    let prompt = if let Some(idx) = prompt_index {
        parse_prompt(&args[idx]).await?
    } else {
        DEFAULT_PROMPT.to_string()
    };
    let return_string = parsed_flag.unwrap_or(false);
    loop {
        let line = interaction::request_line_async(&prompt, true)
            .await
            .map_err(|err| {
                let message = err.message().to_string();
                input_error_with_source(
                    &INPUT_ERROR_INTERACTION_FAILED,
                    format!("input: {message}"),
                    err,
                )
            })?;
        if return_string {
            return Ok(Value::CharArray(CharArray::new_row(&line)));
        }
        if let Ok(value) = parse_numeric_response(&line).await {
            return Ok(value);
        }
    }
}

async fn parse_prompt(value: &Value) -> Result<String, RuntimeError> {
    let gathered = gather_if_needed_async(value).await?;
    match gathered {
        Value::CharArray(ca) => {
            if ca.rows != 1 {
                Err(input_error(&INPUT_ERROR_PROMPT_ROW_VECTOR))
            } else {
                Ok(ca.data.iter().collect())
            }
        }
        Value::String(text) => Ok(text),
        Value::StringArray(sa) => {
            if sa.data.len() == 1 {
                Ok(sa.data[0].clone())
            } else {
                Err(input_error(&INPUT_ERROR_PROMPT_SCALAR_STRING))
            }
        }
        other => Err(input_error_with(
            &INPUT_ERROR_INVALID_PROMPT_TYPE,
            format!("input: invalid prompt type ({other:?})"),
        )),
    }
}

async fn parse_string_flag(value: &Value) -> Result<bool, RuntimeError> {
    let gathered = gather_if_needed_async(value).await?;
    let text = match gathered {
        Value::CharArray(ca) if ca.rows == 1 => ca.data.iter().collect::<String>(),
        Value::String(s) => s,
        Value::StringArray(sa) if sa.data.len() == 1 => sa.data[0].clone(),
        other => {
            return Err(input_error_with(
                &INPUT_ERROR_INVALID_STRING_FLAG,
                format!("input: invalid string flag ({other:?})"),
            ))
        }
    };
    if text == "s" {
        Ok(true)
    } else {
        Err(input_error_with(
            &INPUT_ERROR_INVALID_STRING_FLAG,
            format!("input: invalid string flag ({text})"),
        ))
    }
}

async fn parse_numeric_response(line: &str) -> Result<Value, RuntimeError> {
    let trimmed = line.trim();
    if trimmed.is_empty() || trimmed == "[]" {
        return Ok(Value::Tensor(Tensor::zeros(vec![0, 0])));
    }

    // Fast path 1: scalar literals, named constants, and logical keywords.
    // Handles the vast majority of input() use cases without touching the VM.
    if let Some(v) = parse_scalar_value(trimmed) {
        return Ok(v);
    }

    // Fast path 2: matrix/vector literals like `[1 2 3]`, `[1;2;3]`, `[true false]`.
    // Avoids recursive interpret() calls for this common case.
    if trimmed.starts_with('[') && trimmed.ends_with(']') {
        if let Some(v) = parse_matrix_literal(trimmed) {
            return Ok(v);
        }
    }

    // Full eval path for complex expressions (`sqrt(2)`, `pi/2`, `ones(3)`, etc.).
    // The eval hook is only safe to call when the executor can handle re-entrant
    // polls (e.g. the WASM async runtime). On native the fast paths above cover
    // the common cases; truly complex expressions fall back to str2double here.
    if let Some(hook) = interaction::current_eval_hook() {
        return hook(trimmed.to_string()).await.map_err(|err| {
            let message = err.message().to_string();
            input_error_with_source(
                &INPUT_ERROR_EVAL_FAILED,
                format!("input: invalid expression ({message})"),
                err,
            )
        });
    }

    // Fallback when no eval hook is installed (unit tests, native REPL).
    let parsed = call_builtin_async("str2double", &[Value::String(trimmed.to_string())])
        .await
        .map_err(|err| {
            let message = err.message().to_string();
            input_error_with_source(
                &INPUT_ERROR_INVALID_NUMERIC_EXPRESSION,
                format!("input: invalid numeric expression ({message})"),
                err,
            )
        })?;
    if matches!(parsed, Value::Num(value) if value.is_nan()) {
        return Err(input_error_with(
            &INPUT_ERROR_INVALID_NUMERIC_EXPRESSION,
            INPUT_ERROR_INVALID_NUMERIC_EXPRESSION.message,
        ));
    }
    Ok(parsed)
}

/// Parse a single MATLAB scalar token into a [`Value`].
///
/// Returns [`Value::Bool`] for `true`/`false` (case-insensitive), [`Value::Num`]
/// for numeric literals and named constants (`pi`, `inf`, `nan`), and
/// `None` for anything that looks like a matrix, function call, or unknown
/// identifier.
///
/// Note: `e` is intentionally **not** handled here. It is not a MATLAB built-in
/// constant; typing `e` at an `input()` prompt would perform a variable lookup in
/// MATLAB and error if `e` is undefined. Unknown identifiers fall through to the
/// eval hook or `str2double`, which produce the correct error.
fn parse_scalar_value(s: &str) -> Option<Value> {
    match s.to_ascii_lowercase().as_str() {
        "true" => return Some(Value::Bool(true)),
        "false" => return Some(Value::Bool(false)),
        "pi" => return Some(Value::Num(std::f64::consts::PI)),
        "inf" | "+inf" | "infinity" | "+infinity" => return Some(Value::Num(f64::INFINITY)),
        "-inf" | "-infinity" => return Some(Value::Num(f64::NEG_INFINITY)),
        "nan" => return Some(Value::Num(f64::NAN)),
        _ => {}
    }
    // Plain numeric literals: integers, decimals, scientific notation, optional sign.
    // We reject anything containing brackets, commas, spaces (which would indicate a
    // matrix or an expression), or letters other than 'e'/'E' for exponent notation.
    let has_non_numeric = s.chars().any(|c| {
        matches!(c, '[' | ']' | ',' | ';' | '(' | ')' | ' ' | '\t')
            || (c.is_ascii_alphabetic() && c != 'e' && c != 'E' && c != 'i' && c != 'j')
    });
    if has_non_numeric {
        return None;
    }
    s.parse::<f64>().ok().map(Value::Num)
}

/// Parse a MATLAB matrix literal of the form `[elements]`.
///
/// Rows are separated by `;` and elements within a row by whitespace and/or `,`.
/// Every element must be a token accepted by [`parse_scalar_value`].
/// Returns `None` if the literal is malformed or contains non-scalar elements.
///
/// Output type mirrors MATLAB semantics:
/// - All-logical elements → [`Value::LogicalArray`]
/// - Any numeric element  → [`Value::Tensor`] (logical elements coerced to `f64`)
fn parse_matrix_literal(s: &str) -> Option<Value> {
    let inner = s.strip_prefix('[')?.strip_suffix(']')?;
    let inner = inner.trim();
    if inner.is_empty() {
        return Some(Value::Tensor(Tensor::zeros(vec![0, 0])));
    }

    let row_strs: Vec<&str> = inner.split(';').collect();
    let mut values: Vec<Value> = Vec::new();
    let mut nrows = 0usize;
    let mut ncols: Option<usize> = None;

    for row_str in &row_strs {
        let tokens: Vec<&str> = row_str
            .split(|c: char| c == ',' || c.is_ascii_whitespace())
            .filter(|t| !t.is_empty())
            .collect();
        if tokens.is_empty() {
            continue;
        }
        match ncols {
            None => ncols = Some(tokens.len()),
            Some(expected) if tokens.len() != expected => return None,
            _ => {}
        }
        for token in &tokens {
            values.push(parse_scalar_value(token)?);
        }
        nrows += 1;
    }

    let ncols = ncols.unwrap_or(0);
    if nrows == 0 || ncols == 0 {
        return Some(Value::Tensor(Tensor::zeros(vec![0, 0])));
    }
    // Scalar: preserve the exact type (Bool or Num) rather than always wrapping in Tensor.
    if nrows == 1 && ncols == 1 {
        return Some(values.remove(0));
    }

    // All-logical → LogicalArray; any numeric element → Tensor (bools coerced to f64).
    // `values` is in row-major order (row 0 left-to-right, then row 1, …), but both
    // Tensor and LogicalArray store data in column-major order (data[r + c*rows]).
    // Reorder so that column-major index maps to the correct element.
    let all_logical = values.iter().all(|v| matches!(v, Value::Bool(_)));
    if all_logical {
        let mut data: Vec<u8> = vec![0u8; nrows * ncols];
        for r in 0..nrows {
            for c in 0..ncols {
                let row_major_idx = r * ncols + c;
                let col_major_idx = r + c * nrows;
                data[col_major_idx] = match &values[row_major_idx] {
                    Value::Bool(b) => u8::from(*b),
                    _ => unreachable!(),
                };
            }
        }
        LogicalArray::new(data, vec![nrows, ncols])
            .ok()
            .map(Value::LogicalArray)
    } else {
        let mut data: Vec<f64> = vec![0f64; nrows * ncols];
        for r in 0..nrows {
            for c in 0..ncols {
                let row_major_idx = r * ncols + c;
                let col_major_idx = r + c * nrows;
                data[col_major_idx] = match &values[row_major_idx] {
                    Value::Num(f) => *f,
                    Value::Bool(b) => f64::from(u8::from(*b)),
                    _ => unreachable!(),
                };
            }
        }
        Tensor::new_2d(data, nrows, ncols).ok().map(Value::Tensor)
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;
    use crate::interaction::{push_queued_response, InteractionResponse};

    fn input_with_empty_prompt() -> BuiltinResult<Value> {
        futures::executor::block_on(input_builtin(vec![Value::String(String::new())]))
    }

    #[test]
    fn input_descriptor_signatures_cover_core_forms() {
        let labels: Vec<&str> = INPUT_DESCRIPTOR
            .signatures
            .iter()
            .map(|sig| sig.label)
            .collect();
        assert!(labels.contains(&"value = input()"));
        assert!(labels.contains(&"value = input(prompt)"));
        assert!(labels.contains(&"value = input(prompt, stringFlag)"));
        assert!(labels.contains(&"value = input(stringFlag, prompt)"));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn numeric_input_parses_scalar() {
        push_queued_response(Ok(InteractionResponse::Line("41".into())));
        let value = input_with_empty_prompt().expect("input");
        assert_eq!(value, Value::Num(41.0));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn string_mode_returns_char_row() {
        push_queued_response(Ok(InteractionResponse::Line("RunMat".into())));
        let prompt = Value::CharArray(CharArray::new_row("Name: "));
        let mode = Value::String("s".to_string());
        let value = futures::executor::block_on(input_builtin(vec![prompt, mode])).expect("input");
        assert_eq!(value, Value::CharArray(CharArray::new_row("RunMat")));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn empty_response_returns_empty_tensor() {
        push_queued_response(Ok(InteractionResponse::Line("   ".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::Tensor(t) => assert!(t.materialize_f64().is_empty()),
            other => panic!("expected empty tensor, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn matrix_literal_parses_without_eval_hook() {
        // The fast-path parser handles `[1 2 3]` directly, so no eval hook (and
        // therefore no recursive interpret() call) is needed.
        push_queued_response(Ok(InteractionResponse::Line("[1 2 3]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::Tensor(t) => {
                assert_eq!(t.rows, 1);
                assert_eq!(t.cols, 3);
                assert_eq!(t.materialize_f64(), vec![1.0, 2.0, 3.0]);
            }
            other => panic!("expected 1×3 tensor, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn named_constants_parse_without_eval_hook() {
        push_queued_response(Ok(InteractionResponse::Line("pi".into())));
        let value = input_with_empty_prompt().expect("input");
        assert_eq!(value, Value::Num(std::f64::consts::PI));
    }

    /// `e` is not a MATLAB built-in constant. The fast-path parser must not map
    /// it to Euler's number; it should fall through so the eval hook or
    /// `str2double` can handle it (which will NaN or error on an unknown identifier).
    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn bare_e_is_not_eulers_number() {
        assert_eq!(parse_scalar_value("e"), None);
        assert_eq!(parse_scalar_value("E"), None);
    }

    /// `[1 e 3]` must not silently produce `[1.0, 2.718…, 3.0]`.
    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn matrix_with_bare_e_does_not_parse() {
        assert_eq!(parse_matrix_literal("[1 e 3]"), None);
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn true_input_returns_logical_not_double() {
        push_queued_response(Ok(InteractionResponse::Line("true".into())));
        let value = input_with_empty_prompt().expect("input");
        assert_eq!(value, Value::Bool(true));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn false_input_returns_logical_not_double() {
        push_queued_response(Ok(InteractionResponse::Line("false".into())));
        let value = input_with_empty_prompt().expect("input");
        assert_eq!(value, Value::Bool(false));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn bool_input_is_case_insensitive() {
        push_queued_response(Ok(InteractionResponse::Line("TRUE".into())));
        let value = input_with_empty_prompt().expect("input");
        assert_eq!(value, Value::Bool(true));
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn column_vector_parses_without_eval_hook() {
        push_queued_response(Ok(InteractionResponse::Line("[1;2;3]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::Tensor(t) => {
                assert_eq!(t.rows, 3);
                assert_eq!(t.cols, 1);
                assert_eq!(t.materialize_f64(), vec![1.0, 2.0, 3.0]);
            }
            other => panic!("expected 3×1 tensor, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn logical_row_vector_parses_as_logical_array() {
        push_queued_response(Ok(InteractionResponse::Line("[true false]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::LogicalArray(la) => {
                assert_eq!(la.shape, vec![1, 2]);
                assert_eq!(la.data, vec![1, 0]);
            }
            other => panic!("expected LogicalArray, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn logical_column_vector_parses_as_logical_array() {
        push_queued_response(Ok(InteractionResponse::Line("[true; false]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::LogicalArray(la) => {
                assert_eq!(la.shape, vec![2, 1]);
                assert_eq!(la.data, vec![1, 0]);
            }
            other => panic!("expected LogicalArray, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn mixed_logical_and_numeric_coerces_to_double_tensor() {
        push_queued_response(Ok(InteractionResponse::Line("[true 2.0]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::Tensor(t) => {
                assert_eq!(t.rows, 1);
                assert_eq!(t.cols, 2);
                assert_eq!(t.materialize_f64(), vec![1.0, 2.0]);
            }
            other => panic!("expected Tensor, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn matrix_2x2_column_major_layout() {
        // [1 2; 3 4] → get2(r,c) must return element at row r, col c, not the transpose.
        // Column-major storage: data = [1, 3, 2, 4] (not the row-major [1, 2, 3, 4]).
        push_queued_response(Ok(InteractionResponse::Line("[1 2; 3 4]".into())));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::Tensor(t) => {
                assert_eq!(t.rows, 2);
                assert_eq!(t.cols, 2);
                assert_eq!(t.get2(0, 0).unwrap(), 1.0, "(0,0) should be 1");
                assert_eq!(t.get2(0, 1).unwrap(), 2.0, "(0,1) should be 2");
                assert_eq!(t.get2(1, 0).unwrap(), 3.0, "(1,0) should be 3");
                assert_eq!(t.get2(1, 1).unwrap(), 4.0, "(1,1) should be 4");
            }
            other => panic!("expected 2×2 tensor, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn logical_matrix_2x2_column_major_layout() {
        // [true false; false true] → column-major data = [1, 0, 0, 1].
        push_queued_response(Ok(InteractionResponse::Line(
            "[true false; false true]".into(),
        )));
        let value = input_with_empty_prompt().expect("input");
        match value {
            Value::LogicalArray(la) => {
                assert_eq!(la.shape, vec![2, 2]);
                // column-major: col 0 first ([true, false]), then col 1 ([false, true])
                assert_eq!(la.data, vec![1, 0, 0, 1]);
            }
            other => panic!("expected 2×2 LogicalArray, got {other:?}"),
        }
    }

    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
    #[test]
    fn invalid_string_flag_errors_before_prompt() {
        push_queued_response(Ok(InteractionResponse::Line("ignored".into())));
        let prompt = Value::String("Ready?".to_string());
        let bad_flag = Value::String("not-string-mode".to_string());
        let err = futures::executor::block_on(input_builtin(vec![prompt, bad_flag])).unwrap_err();
        assert_eq!(err.identifier(), Some("RunMat:input:InvalidStringFlag"));
    }

    #[test]
    fn strict_mode_gates_runmat_only_call_forms_before_interaction() {
        let _compat = crate::compatibility::push_runmat_extensions_enabled(false);
        let no_prompt = futures::executor::block_on(input_builtin(vec![])).unwrap_err();
        assert_eq!(
            no_prompt.identifier(),
            INPUT_NO_PROMPT_EXTENSION.error_identifier
        );
        let swapped = futures::executor::block_on(input_builtin(vec![
            Value::String("s".into()),
            Value::String("Prompt: ".into()),
        ]))
        .unwrap_err();
        assert_eq!(
            swapped.identifier(),
            INPUT_SWAPPED_ARGUMENTS_EXTENSION.error_identifier
        );
    }

    #[test]
    fn resident_prompt_rejects_without_provider_access() {
        let resident = Value::GpuTensor(runmat_accelerate_api::GpuTensorHandle {
            shape: vec![1, 1],
            device_id: u32::MAX,
            buffer_id: u64::MAX,
            descriptor: Default::default(),
        });
        let error = futures::executor::block_on(input_builtin(vec![resident])).unwrap_err();
        assert_eq!(
            error.identifier(),
            INPUT_ERROR_INVALID_PROMPT_TYPE.identifier
        );
    }

    #[test]
    fn input_integer_audit_is_explicitly_not_applicable() {
        assert_eq!(
            INPUT_INTEGER_AUDIT.kind,
            BuiltinIntegerAuditKind::NotApplicable
        );
        assert_eq!(INPUT_EXTENSIONS.len(), 2);
    }
}