@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_core/src/value.rs

@@ -0,0 +1,376 @@
+//! Unified Value type for Tish runtime values.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+
+#[cfg(feature = "regex")]
+use fancy_regex::Regex;
+
+/// Native function signature.
+/// Returns Value directly (not Result) for simplicity and backward compatibility.
+pub type NativeFn = Rc<dyn Fn(&[Value]) -> Value>;
+
+/// Trait for opaque Rust types exposed to Tish (e.g. Polars DataFrame).
+/// Implementors provide method dispatch so Tish can call methods on the value.
+pub trait TishOpaque: Send + Sync {
+    /// Display name for the type (e.g. "DataFrame").
+    fn type_name(&self) -> &'static str;
+
+    /// Get a method by name. Returns a native function if the method exists.
+    fn get_method(&self, name: &str) -> Option<NativeFn>;
+}
+
+/// Trait for Promise-like values that can be awaited (block until settled).
+/// Implemented by the runtime for native compile; interpreter uses its own Promise.
+pub trait TishPromise: Send + Sync {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value>;
+}
+
+/// JavaScript RegExp flags
+#[cfg(feature = "regex")]
+#[derive(Debug, Clone, Default)]
+pub struct RegExpFlags {
+    pub global: bool,
+    pub ignore_case: bool,
+    pub multiline: bool,
+    pub dot_all: bool,
+    pub unicode: bool,
+    pub sticky: bool,
+}
+
+#[cfg(feature = "regex")]
+impl RegExpFlags {
+    pub fn from_string(flags: &str) -> Result<Self, String> {
+        let mut result = Self::default();
+        for c in flags.chars() {
+            match c {
+                'g' => { if result.global { return Err(format!("duplicate flag '{}'", c)); } result.global = true; }
+                'i' => { if result.ignore_case { return Err(format!("duplicate flag '{}'", c)); } result.ignore_case = true; }
+                'm' => { if result.multiline { return Err(format!("duplicate flag '{}'", c)); } result.multiline = true; }
+                's' => { if result.dot_all { return Err(format!("duplicate flag '{}'", c)); } result.dot_all = true; }
+                'u' => { if result.unicode { return Err(format!("duplicate flag '{}'", c)); } result.unicode = true; }
+                'y' => { if result.sticky { return Err(format!("duplicate flag '{}'", c)); } result.sticky = true; }
+                _ => return Err(format!("unknown flag '{}'", c)),
+            }
+        }
+        Ok(result)
+    }
+
+}
+
+#[cfg(feature = "regex")]
+impl std::fmt::Display for RegExpFlags {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.global { f.write_str("g")?; }
+        if self.ignore_case { f.write_str("i")?; }
+        if self.multiline { f.write_str("m")?; }
+        if self.dot_all { f.write_str("s")?; }
+        if self.unicode { f.write_str("u")?; }
+        if self.sticky { f.write_str("y")?; }
+        Ok(())
+    }
+}
+
+/// Tish RegExp object
+#[cfg(feature = "regex")]
+#[derive(Debug, Clone)]
+pub struct TishRegExp {
+    pub source: String,
+    pub flags: RegExpFlags,
+    pub regex: Arc<Regex>,
+    pub last_index: usize,
+}
+
+#[cfg(feature = "regex")]
+impl TishRegExp {
+    pub fn new(pattern: &str, flags_str: &str) -> Result<Self, String> {
+        let flags = RegExpFlags::from_string(flags_str)?;
+        let mut regex_pattern = pattern.to_string();
+        
+        if flags.ignore_case || flags.multiline || flags.dot_all {
+            let mut flag_prefix = String::from("(?");
+            if flags.ignore_case { flag_prefix.push('i'); }
+            if flags.multiline { flag_prefix.push('m'); }
+            if flags.dot_all { flag_prefix.push('s'); }
+            flag_prefix.push(')');
+            regex_pattern = format!("{}{}", flag_prefix, regex_pattern);
+        }
+        
+        let regex = Regex::new(&regex_pattern)
+            .map_err(|e| format!("Invalid regular expression: {}", e))?;
+        
+        Ok(Self { source: pattern.to_string(), flags, regex: Arc::new(regex), last_index: 0 })
+    }
+
+    pub fn flags_string(&self) -> String { self.flags.to_string() }
+
+    pub fn test(&mut self, input: &str) -> bool {
+        if self.flags.global || self.flags.sticky {
+            let start = self.last_index;
+            if start > input.chars().count() {
+                self.last_index = 0;
+                return false;
+            }
+            
+            let byte_start: usize = input.chars().take(start).map(|c| c.len_utf8()).sum();
+            let search_str = &input[byte_start..];
+            
+            match self.regex.find(search_str) {
+                Ok(Some(m)) => {
+                    if self.flags.sticky && m.start() != 0 {
+                        self.last_index = 0;
+                        return false;
+                    }
+                    let match_end_chars = input[byte_start..byte_start + m.end()].chars().count();
+                    self.last_index = start + match_end_chars;
+                    true
+                }
+                _ => {
+                    self.last_index = 0;
+                    false
+                }
+            }
+        } else {
+            self.regex.is_match(input).unwrap_or(false)
+        }
+    }
+}
+
+/// Runtime value for Tish programs.
+/// Used by both interpreter and compiled code.
+#[derive(Clone)]
+pub enum Value {
+    Number(f64),
+    String(Arc<str>),
+    Bool(bool),
+    Null,
+    Array(Rc<RefCell<Vec<Value>>>),
+    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    Function(NativeFn),
+    #[cfg(feature = "regex")]
+    RegExp(Rc<RefCell<TishRegExp>>),
+    /// Promise (for native compile). Interpreter uses tish_eval::Value::Promise.
+    Promise(Arc<dyn TishPromise>),
+    /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
+    Opaque(Arc<dyn TishOpaque>),
+}
+
+impl std::fmt::Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "Number({})", n),
+            Value::String(s) => write!(f, "String({:?})", s.as_ref()),
+            Value::Bool(b) => write!(f, "Bool({})", b),
+            Value::Null => write!(f, "Null"),
+            Value::Array(arr) => write!(f, "Array({:?})", arr.borrow()),
+            Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
+            Value::Function(_) => write!(f, "Function"),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            Value::Promise(_) => write!(f, "Promise"),
+            Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
+        }
+    }
+}
+
+impl Value {
+    /// Convert value to display string (for console output).
+    pub fn to_display_string(&self) -> String {
+        match self {
+            Value::Number(n) => {
+                if n.is_nan() {
+                    "NaN".to_string()
+                } else if *n == f64::INFINITY {
+                    "Infinity".to_string()
+                } else if *n == f64::NEG_INFINITY {
+                    "-Infinity".to_string()
+                } else {
+                    n.to_string()
+                }
+            }
+            Value::String(s) => s.to_string(),
+            Value::Bool(b) => b.to_string(),
+            Value::Null => "null".to_string(),
+            Value::Array(arr) => {
+                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_display_string()).collect();
+                format!("[{}]", inner.join(", "))
+            }
+            Value::Object(obj) => {
+                let inner: Vec<String> = obj
+                    .borrow()
+                    .iter()
+                    .map(|(k, v)| format!("{}: {}", k.as_ref(), v.to_display_string()))
+                    .collect();
+                format!("{{{}}}", inner.join(", "))
+            }
+            Value::Function(_) => "[Function]".to_string(),
+            Value::Promise(_) => "[object Promise]".to_string(),
+            Value::Opaque(o) => format!("[object {}]", o.type_name()),
+            #[cfg(feature = "regex")]
+            Value::RegExp(re) => {
+                let re = re.borrow();
+                format!("/{}/{}", re.source, re.flags_string())
+            }
+        }
+    }
+
+    /// Check if value is truthy (for conditionals).
+    pub fn is_truthy(&self) -> bool {
+        match self {
+            Value::Null => false,
+            Value::Bool(b) => *b,
+            Value::Number(n) => *n != 0.0 && !n.is_nan(),
+            Value::String(s) => !s.is_empty(),
+            _ => true,
+        }
+    }
+
+    /// Strict equality (===).
+    pub fn strict_eq(&self, other: &Value) -> bool {
+        match (self, other) {
+            (Value::Number(a), Value::Number(b)) => {
+                if a.is_nan() || b.is_nan() {
+                    false
+                } else {
+                    a == b
+                }
+            }
+            (Value::String(a), Value::String(b)) => a == b,
+            (Value::Bool(a), Value::Bool(b)) => a == b,
+            (Value::Null, Value::Null) => true,
+            (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
+            (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
+            (Value::Function(a), Value::Function(b)) => Rc::ptr_eq(a, b),
+            #[cfg(feature = "regex")]
+            (Value::RegExp(a), Value::RegExp(b)) => Rc::ptr_eq(a, b),
+            (Value::Promise(a), Value::Promise(b)) => Arc::ptr_eq(a, b),
+            (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
+            _ => false,
+        }
+    }
+
+    /// Create a new array Value from a Vec.
+    pub fn array(items: Vec<Value>) -> Self {
+        Value::Array(Rc::new(RefCell::new(items)))
+    }
+
+    /// Create a new object Value from a HashMap.
+    pub fn object(map: HashMap<Arc<str>, Value>) -> Self {
+        Value::Object(Rc::new(RefCell::new(map)))
+    }
+
+    /// Create an empty array Value.
+    pub fn empty_array() -> Self {
+        Value::Array(Rc::new(RefCell::new(Vec::new())))
+    }
+
+    /// Create an empty object Value.
+    pub fn empty_object() -> Self {
+        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+    }
+
+    /// Extract the number value, if this is a Number.
+    pub fn as_number(&self) -> Option<f64> {
+        match self {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        }
+    }
+
+    /// JavaScript-style typeof string for this value.
+    pub fn type_name(&self) -> &'static str {
+        match self {
+            Value::Number(_) => "number",
+            Value::String(_) => "string",
+            Value::Bool(_) => "boolean",
+            Value::Null => "null",
+            Value::Array(_) => "object",
+            Value::Object(_) => "object",
+            Value::Function(_) => "function",
+            #[cfg(feature = "regex")]
+            Value::RegExp(_) => "object",
+            Value::Promise(_) => "object",
+            Value::Opaque(o) => o.type_name(),
+        }
+    }
+
+    /// Property/method names for REPL tab completion (e.g. after `obj.`).
+    pub fn completion_keys(&self) -> Vec<String> {
+        match self {
+            Value::Object(m) => {
+                let mut keys: Vec<String> = m.borrow().keys().map(|k| k.to_string()).collect();
+                keys.sort();
+                keys
+            }
+            Value::Array(_) => {
+                vec![
+                    "length".into(),
+                    "at".into(),
+                    "concat".into(),
+                    "copyWithin".into(),
+                    "entries".into(),
+                    "every".into(),
+                    "fill".into(),
+                    "filter".into(),
+                    "find".into(),
+                    "findIndex".into(),
+                    "findLast".into(),
+                    "findLastIndex".into(),
+                    "flat".into(),
+                    "flatMap".into(),
+                    "forEach".into(),
+                    "includes".into(),
+                    "indexOf".into(),
+                    "join".into(),
+                    "keys".into(),
+                    "lastIndexOf".into(),
+                    "map".into(),
+                    "pop".into(),
+                    "push".into(),
+                    "reduce".into(),
+                    "reduceRight".into(),
+                    "reverse".into(),
+                    "shift".into(),
+                    "slice".into(),
+                    "some".into(),
+                    "sort".into(),
+                    "splice".into(),
+                    "toLocaleString".into(),
+                    "toReversed".into(),
+                    "toSorted".into(),
+                    "toSpliced".into(),
+                    "toString".into(),
+                    "unshift".into(),
+                    "values".into(),
+                    "shuffle".into(),
+                ]
+            }
+            Value::String(_) => {
+                vec![
+                    "length".into(),
+                    "charAt".into(),
+                    "charCodeAt".into(),
+                    "endsWith".into(),
+                    "includes".into(),
+                    "indexOf".into(),
+                    "padEnd".into(),
+                    "padStart".into(),
+                    "repeat".into(),
+                    "replace".into(),
+                    "replaceAll".into(),
+                    "slice".into(),
+                    "split".into(),
+                    "startsWith".into(),
+                    "substring".into(),
+                    "toLowerCase".into(),
+                    "toUpperCase".into(),
+                    "trim".into(),
+                ]
+            }
+            Value::Number(_) => vec!["toFixed".into(), "toExponential".into(), "toPrecision".into()],
+            _ => vec![],
+        }
+    }
+}

package/crates/tish_cranelift/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tish_cranelift"
+version = "0.1.0"
+edition = "2021"
+description = "Bytecode to native via Cranelift"
+
+[dependencies]
+tish_build_utils = { path = "../tish_build_utils" }
+cranelift = "0.130"
+cranelift-codegen = "0.130"
+cranelift-frontend = "0.130"
+cranelift-module = "0.130"
+cranelift-native = "0.130"
+cranelift-object = "0.130"
+target-lexicon = "0.13"
+tish_bytecode = { path = "../tish_bytecode" }
+tish_core = { path = "../tish_core" }

package/crates/tish_cranelift/src/lib.rs

@@ -0,0 +1,41 @@
+//! Bytecode to native via Cranelift.
+//!
+//! Compiles Tish bytecode to native object files and links with a minimal runtime.
+
+mod link;
+mod lower;
+
+pub use link::link_to_binary;
+
+use std::path::Path;
+
+use tish_bytecode::Chunk;
+
+/// Error from Cranelift compilation.
+#[derive(Debug)]
+pub struct CraneliftError {
+    pub message: String,
+}
+
+impl std::fmt::Display for CraneliftError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for CraneliftError {}
+
+/// Compile a bytecode chunk to a native binary.
+/// `features` are passed to tish_cranelift_runtime (e.g. fs, process, http for built-in modules).
+pub fn compile_chunk_to_native(
+    chunk: &Chunk,
+    output_path: &Path,
+    features: &[String],
+) -> Result<(), CraneliftError> {
+    let object_path = output_path.with_extension("o");
+    lower::lower_and_emit(chunk, &object_path)?;
+    link::link_to_binary(&object_path, output_path, features)?;
+    // Clean up .o file
+    let _ = std::fs::remove_file(&object_path);
+    Ok(())
+}

package/crates/tish_cranelift/src/link.rs

@@ -0,0 +1,120 @@
+//! Link object file with runtime to produce final binary.
+//!
+//! Uses Cargo to build a small binary that links our .o and runs the chunk.
+
+use std::fs;
+use std::path::Path;
+
+use crate::CraneliftError;
+
+pub fn link_to_binary(
+    object_path: &Path,
+    output_path: &Path,
+    features: &[String],
+) -> Result<(), CraneliftError> {
+    let workspace_root = tish_build_utils::find_workspace_root().map_err(|e| CraneliftError {
+        message: e,
+    })?;
+    let out_name = output_path
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("tish_out");
+    let build_dir = tish_build_utils::create_build_dir("tish_cranelift_build", out_name)
+        .map_err(|e| CraneliftError { message: e })?;
+
+    let object_path_str = object_path
+        .canonicalize()
+        .map_err(|e| CraneliftError {
+            message: format!("Cannot canonicalize object path: {}", e),
+        })?
+        .display()
+        .to_string()
+        .replace('\\', "/");
+
+    // tish_cranelift_runtime path (workspace/crates/tish_cranelift_runtime)
+    let runtime_path = workspace_root
+        .join("crates")
+        .join("tish_cranelift_runtime")
+        .canonicalize()
+        .map_err(|e| CraneliftError {
+            message: format!("Cannot find tish_cranelift_runtime: {}", e),
+        })?
+        .display()
+        .to_string()
+        .replace('\\', "/");
+
+    let features_str = if features.is_empty() {
+        String::new()
+    } else {
+        format!(
+            ", features = [{}]",
+            features
+                .iter()
+                .map(|f| format!("{:?}", f))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+    let cargo_toml_fixed = format!(
+        r#"[package]
+name = "tish_cranelift_out"
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = "{}"
+path = "src/main.rs"
+
+[dependencies]
+tish_cranelift_runtime = {{ path = {:?}{} }}
+"#,
+        out_name, runtime_path, features_str
+    );
+
+    let main_rs = r#"
+extern "C" {
+    static tish_chunk_data: [u8; 1];
+    static tish_chunk_len: u64;
+}
+
+fn main() {
+    let len = unsafe { tish_chunk_len } as usize;
+    let ptr = unsafe { tish_chunk_data.as_ptr() };
+    let exit_code = tish_cranelift_runtime::tish_run_chunk(ptr, len);
+    std::process::exit(exit_code);
+}
+"#;
+
+    let build_rs = format!(
+        r#"
+fn main() {{
+    println!("cargo:rustc-link-arg={}");
+}}
+"#,
+        object_path_str
+    );
+
+    fs::write(build_dir.join("Cargo.toml"), cargo_toml_fixed).map_err(|e| CraneliftError {
+        message: format!("Cannot write Cargo.toml: {}", e),
+    })?;
+    fs::write(build_dir.join("src/main.rs"), main_rs).map_err(|e| CraneliftError {
+        message: format!("Cannot write main.rs: {}", e),
+    })?;
+    fs::write(build_dir.join("build.rs"), build_rs).map_err(|e| CraneliftError {
+        message: format!("Cannot write build.rs: {}", e),
+    })?;
+
+    tish_build_utils::run_cargo_build(&build_dir, None).map_err(|e| CraneliftError { message: e })?;
+
+    let binary_dir = build_dir.join("target").join("release");
+    let binary =
+        tish_build_utils::find_release_binary(&binary_dir, out_name)
+            .map_err(|e| CraneliftError { message: e })?;
+    let target = tish_build_utils::resolve_output_path(output_path, out_name);
+    tish_build_utils::copy_binary_to_output(&binary, &target)
+        .map_err(|e| CraneliftError { message: e })?;
+
+    Ok(())
+}
+
+

package/crates/tish_cranelift/src/lower.rs

@@ -0,0 +1,77 @@
+//! Bytecode to Cranelift IR lowering.
+//!
+//! Emits object file with tish_chunk_data and tish_chunk_len symbols.
+//! The link step builds a Rust binary that reads these and runs via tish_vm.
+
+use std::path::Path;
+
+use cranelift::codegen::settings::Configurable;
+use cranelift::codegen::settings;
+use cranelift_module::{DataDescription, Linkage, Module};
+use cranelift_object::{ObjectBuilder, ObjectModule};
+
+use tish_bytecode::{serialize, Chunk};
+
+use crate::CraneliftError;
+
+pub fn lower_and_emit(chunk: &Chunk, object_path: &Path) -> Result<(), CraneliftError> {
+    let mut settings_builder = settings::builder();
+    settings_builder.set("opt_level", "speed").map_err(|_| CraneliftError {
+        message: "Failed to set opt_level".to_string(),
+    })?;
+    let flags = settings::Flags::new(settings_builder);
+
+    let isa_builder = cranelift_native::builder().map_err(|e| CraneliftError {
+        message: format!("Failed to build ISA: {}", e),
+    })?;
+    let isa = isa_builder.finish(flags).map_err(|e| CraneliftError {
+        message: format!("Failed to finish ISA: {}", e),
+    })?;
+
+    let object_builder = ObjectBuilder::new(isa, "tish_cranelift", cranelift_module::default_libcall_names())
+        .map_err(|e| CraneliftError {
+            message: format!("Failed to create ObjectBuilder: {}", e),
+        })?;
+    let mut module = ObjectModule::new(object_builder);
+
+    // Serialize chunk and emit as data - link step will build a Rust binary that reads it
+    let chunk_data = serialize(chunk);
+    let chunk_len = chunk_data.len() as u64;
+    let data_id = module
+        .declare_data("tish_chunk_data", Linkage::Export, false, false)
+        .map_err(|e| CraneliftError {
+            message: format!("Failed to declare chunk data: {}", e),
+        })?;
+    let mut data_desc = DataDescription::new();
+    data_desc.define(chunk_data.into_boxed_slice());
+    module
+        .define_data(data_id, &data_desc)
+        .map_err(|e| CraneliftError {
+            message: format!("Failed to define chunk data: {}", e),
+        })?;
+
+    let len_data = chunk_len.to_le_bytes();
+    let len_id = module
+        .declare_data("tish_chunk_len", Linkage::Export, false, false)
+        .map_err(|e| CraneliftError {
+            message: format!("Failed to declare chunk len: {}", e),
+        })?;
+    let mut len_desc = DataDescription::new();
+    len_desc.define(len_data.to_vec().into_boxed_slice());
+    module
+        .define_data(len_id, &len_desc)
+        .map_err(|e| CraneliftError {
+            message: format!("Failed to define chunk len: {}", e),
+        })?;
+
+    let object_product = module.finish();
+    let bytes = object_product.emit().map_err(|e| CraneliftError {
+        message: format!("Failed to emit object: {}", e),
+    })?;
+
+    std::fs::write(object_path, bytes).map_err(|e| CraneliftError {
+        message: format!("Failed to write object file: {}", e),
+    })?;
+
+    Ok(())
+}

package/crates/tish_cranelift_runtime/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tish_cranelift_runtime"
+version = "0.1.0"
+edition = "2021"
+description = "Runtime for Cranelift-compiled Tish bytecode"
+
+[features]
+default = []
+fs = ["tish_vm/fs"]
+process = ["tish_vm/process"]
+http = ["tish_vm/http"]
+
+[lib]
+crate-type = ["staticlib", "rlib"]
+
+[dependencies]
+tish_bytecode = { path = "../tish_bytecode" }
+tish_vm = { path = "../tish_vm" }
+tish_core = { path = "../tish_core" }

package/crates/tish_cranelift_runtime/src/lib.rs

@@ -0,0 +1,43 @@
+//! Runtime for Cranelift-compiled Tish programs.
+//!
+//! Provides tish_run_chunk(ptr, len) which deserializes and runs bytecode.
+
+use tish_bytecode::deserialize;
+use tish_vm::Vm;
+
+/// Serialization format:
+/// - u64: code len
+/// - bytes: code
+/// - u64: constants count
+/// - for each constant: u8 tag + payload
+/// - u64: names count
+/// - for each name: u64 len + bytes
+///
+/// Rust-callable wrapper. Run serialized chunk data. Returns exit code (0 on success).
+pub fn tish_run_chunk(ptr: *const u8, len: usize) -> i32 {
+    tish_run_chunk_impl(ptr, len)
+}
+
+#[no_mangle]
+extern "C" fn tish_run_chunk_impl(ptr: *const u8, len: usize) -> i32 {
+    if ptr.is_null() || len < 8 {
+        return 1;
+    }
+    let slice = unsafe { std::slice::from_raw_parts(ptr, len) };
+    match deserialize(slice) {
+        Ok(chunk) => {
+            let mut vm = Vm::new();
+            match vm.run(&chunk) {
+                Ok(_) => 0,
+                Err(e) => {
+                    eprintln!("Runtime error: {}", e);
+                    1
+                }
+            }
+        }
+        Err(e) => {
+            eprintln!("Deserialization error: {}", e);
+            1
+        }
+    }
+}