@tishlang/tish 1.0.13 → 1.0.14

package/crates/tish_compile/src/lib.rs

@@ -1,6 +1,6 @@
 //! Native compiler backend for Tish.
 //!
-//! Emits Rust source that links to tish_runtime.
+//! Emits Rust source that links to tishlang_runtime.
 
 mod codegen;
 mod resolve;
@@ -21,7 +21,7 @@ pub use types::{RustType, TypeContext};
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tish_parser::parse;
+    use tishlang_parser::parse;
 
     #[test]
     fn typed_assign_conversion() {

package/crates/tish_compile/src/resolve.rs

@@ -4,7 +4,7 @@
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use tish_ast::{ExportDeclaration, Expr, ImportSpecifier, Program, Statement};
+use tishlang_ast::{ExportDeclaration, Expr, ImportSpecifier, Program, Statement};
 
 /// Resolved native module: crate path and init expression.
 #[derive(Debug, Clone)]
@@ -37,14 +37,14 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
         .map(|(_, canonical)| (*canonical).to_string())
 }
 
-/// Built-in modules that come from tish_runtime, not from package.json.
+/// Built-in modules that come from tishlang_runtime, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
     matches!(spec, "tish:fs" | "tish:http" | "tish:process" | "tish:ws")
         || matches!(spec, "fs" | "http" | "process" | "ws")
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
-/// Built-in modules (tish:fs, tish:http, tish:process) are skipped - they use tish_runtime directly.
+/// Built-in modules (tish:fs, tish:http, tish:process) are skipped - they use tishlang_runtime directly.
 pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<Vec<ResolvedNativeModule>, String> {
     let root_canon = project_root
         .canonicalize()
@@ -59,7 +59,7 @@ pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<
         {
             let s = spec.as_ref();
             if is_builtin_native_spec(s) {
-                continue; // Built-ins use tish_runtime, no package.json lookup
+                continue; // Built-ins use tishlang_runtime, no package.json lookup
             }
             if !seen.insert(s.to_string()) {
                 continue;
@@ -152,7 +152,7 @@ fn read_package_name(pkg_path: &Path) -> Option<String> {
 }
 
 /// Extract Cargo feature names from native imports in a merged program.
-/// Used to enable tish_runtime features based on `import { x } from 'tish:egui'` etc.
+/// Used to enable tishlang_runtime features based on `import { x } from 'tish:egui'` etc.
 pub fn extract_native_import_features(program: &Program) -> Vec<String> {
     let mut features = std::collections::HashSet::new();
     for stmt in &program.statements {
@@ -260,7 +260,7 @@ fn load_module_recursive(
 
     let source = std::fs::read_to_string(&canonical)
         .map_err(|e| format!("Cannot read {}: {}", canonical.display(), e))?;
-    let program = tish_parser::parse(&source)
+    let program = tishlang_parser::parse(&source)
         .map_err(|e| format!("Parse error in {}: {}", canonical.display(), e))?;
 
     // Collect imports and load dependencies first (skip native imports)
@@ -568,7 +568,7 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                             ImportSpecifier::Namespace(ns) => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
-                                    props.push(tish_ast::ObjectProp::KeyValue(
+                                    props.push(tishlang_ast::ObjectProp::KeyValue(
                                         Arc::from(k.clone()),
                                         Expr::Ident {
                                             name: Arc::from(v.clone()),

package/crates/tish_compile/src/types.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
-use tish_ast::TypeAnnotation;
+use tishlang_ast::TypeAnnotation;
 
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]

package/crates/tish_compile_js/Cargo.toml

@@ -1,16 +1,18 @@
 [package]
-name = "tish_compile_js"
+name = "tishlang_compile_js"
 version = "0.1.0"
 edition = "2021"
 description = "Tish to JavaScript transpiler backend"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
 
 [dependencies]
-tish_jsx_web = { path = "../tish_jsx_web" }
+tishlang_jsx_web = { path = "../tish_jsx_web" }
 
-tish_ast = { path = "../tish_ast" }
-tish_compile = { path = "../tish_compile" }
-tish_opt = { path = "../tish_opt" }
-tish_parser = { path = "../tish_parser" }
+tishlang_ast = { path = "../tish_ast" }
+tishlang_compile = { path = "../tish_compile" }
+tishlang_opt = { path = "../tish_opt" }
+tishlang_parser = { path = "../tish_parser" }

package/crates/tish_compile_js/src/codegen.rs

@@ -1,6 +1,6 @@
 //! Code generation: AST -> JavaScript source.
 
-use tish_ast::{
+use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
     JsxAttrValue, JsxChild, JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program,
     Statement, UnaryOp,
@@ -71,7 +71,7 @@ impl Codegen {
     }
 
     fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
-        self.write("// Generated by tish_compile_js\n");
+        self.write("// Generated by tishlang_compile_js\n");
         // First pass: check if JSX is used (we'll set uses_jsx during emit)
         for stmt in &program.statements {
             self.emit_statement(stmt)?;
@@ -84,7 +84,7 @@ impl Codegen {
                 JsxMode::Vdom => {
                     self.output = format!(
                         "{}\n{}",
-                        tish_jsx_web::VDOM_PRELUDE,
+                        tishlang_jsx_web::VDOM_PRELUDE,
                         self.output
                     );
                 }
@@ -331,8 +331,8 @@ impl Codegen {
 
     fn emit_params(
         &mut self,
-        params: &[tish_ast::TypedParam],
-        rest_param: Option<&tish_ast::TypedParam>,
+        params: &[tishlang_ast::TypedParam],
+        rest_param: Option<&tishlang_ast::TypedParam>,
     ) -> Result<String, CompileError> {
         let mut parts: Vec<String> = params
             .iter()
@@ -745,7 +745,7 @@ pub fn compile_with_jsx(
     jsx_mode: JsxMode,
 ) -> Result<String, CompileError> {
     let program = if optimize {
-        tish_opt::optimize(program)
+        tishlang_opt::optimize(program)
     } else {
         program.clone()
     };
@@ -755,21 +755,21 @@ pub fn compile_with_jsx(
 }
 
 /// Compile a project from entry path, resolving and merging modules.
-/// Uses shared resolve from tish_compile (same pipeline as native/WASM).
+/// Uses shared resolve from tishlang_compile (same pipeline as native/WASM).
 pub fn compile_project_with_jsx(
     entry_path: &std::path::Path,
     project_root: Option<&std::path::Path>,
     optimize: bool,
     jsx_mode: JsxMode,
 ) -> Result<String, CompileError> {
-    use tish_ast::Statement;
-    let modules = tish_compile::resolve_project(entry_path, project_root)
+    use tishlang_ast::Statement;
+    let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
-    tish_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
+    tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
     let program = {
-        let prog = tish_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+        let prog = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
         if optimize {
-            tish_opt::optimize(&prog)
+            tishlang_opt::optimize(&prog)
         } else {
             prog
         }

package/crates/tish_compile_js/src/js_intrinsics.rs

@@ -1,7 +1,7 @@
 //! JS-only call sites that require `new` (Tish has no `new`).
 //! Intrinsic names, validation, and runtime preamble live here — main codegen only dispatches.
 
-use tish_ast::{CallArg, Expr};
+use tishlang_ast::{CallArg, Expr};
 
 use crate::error::CompileError;
 

package/crates/tish_compile_js/src/lib.rs

@@ -1,5 +1,5 @@
 //! Tish to JavaScript transpiler backend.
-//! Uses shared resolve from tish_compile for unified pipeline.
+//! Uses shared resolve from tishlang_compile for unified pipeline.
 
 mod codegen;
 mod error;
@@ -14,7 +14,7 @@ pub use error::CompileError;
 /// Default JSX mode lowers to Lattish-style calls (implementation detail). Import what you use from
 /// `lattish` (e.g. `useState`, `createRoot`); the merged bundle includes the JSX runtime from that
 /// module. JSX-only files can use `import {} from "lattish"` to pull it in without bindings.
-pub fn compile(program: &tish_ast::Program, optimize: bool) -> Result<String, CompileError> {
+pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
     compile_with_jsx(program, optimize, JsxMode::LattishH)
 }
 

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -2,7 +2,7 @@
 mod tests {
     use std::io::Write;
 
-    use tish_parser::parse;
+    use tishlang_parser::parse;
 
     use crate::{compile_project_with_jsx, compile_with_jsx, JsxMode};
 
@@ -53,7 +53,7 @@ mod tests {
 
     #[test]
     fn jsx_text_whitespace_via_compile_project() {
-        let dir = std::env::temp_dir().join("tish_compile_project_test");
+        let dir = std::env::temp_dir().join("tishlang_compile_project_test");
         let _ = std::fs::create_dir_all(&dir);
         let path = dir.join("test.tish");
         let src = "fn App() {\n  return <p>First paragraph</p>\n}";

package/crates/tish_compiler_wasm/Cargo.toml

@@ -1,8 +1,10 @@
 [package]
-name = "tish_compiler_wasm"
+name = "tishlang_compiler_wasm"
 version = "0.1.0"
 edition = "2021"
 description = "Tish compiler as WASM for browser (parse + bytecode + JS)"
+license-file = { workspace = true }
+repository = { workspace = true }
 
 [lib]
 crate-type = ["cdylib"]
@@ -12,8 +14,8 @@ base64 = "0.22"
 serde_json = "1.0"
 wasm-bindgen = "0.2"
 
-tish_ast = { path = "../tish_ast" }
-tish_bytecode = { path = "../tish_bytecode" }
-tish_compile_js = { path = "../tish_compile_js" }
-tish_opt = { path = "../tish_opt" }
-tish_parser = { path = "../tish_parser" }
+tishlang_ast = { path = "../tish_ast" }
+tishlang_bytecode = { path = "../tish_bytecode" }
+tishlang_compile_js = { path = "../tish_compile_js" }
+tishlang_opt = { path = "../tish_opt" }
+tishlang_parser = { path = "../tish_parser" }

package/crates/tish_compiler_wasm/src/lib.rs

@@ -10,21 +10,21 @@ mod resolve_virtual;
 use base64::Engine;
 use resolve_virtual::{detect_cycles_virtual, merge_modules_virtual, resolve_virtual};
 use std::collections::HashMap;
-use tish_compile_js::JsxMode;
+use tishlang_compile_js::JsxMode;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
-    let program = tish_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    let program = tish_opt::optimize(&program);
-    let chunk = tish_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    Ok(base64::engine::general_purpose::STANDARD.encode(tish_bytecode::serialize(&chunk)))
+    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program = tishlang_opt::optimize(&program);
+    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
-    let program = tish_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tish_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
         .map_err(|e| JsValue::from_str(&e.message))
 }
 
@@ -36,9 +36,9 @@ pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> R
         .map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
-    let program = tish_opt::optimize(&program);
-    let chunk = tish_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    Ok(base64::engine::general_purpose::STANDARD.encode(tish_bytecode::serialize(&chunk)))
+    let program = tishlang_opt::optimize(&program);
+    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
 #[wasm_bindgen]
@@ -49,7 +49,7 @@ pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<
         .map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
-    let program = tish_opt::optimize(&program);
-    tish_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    let program = tishlang_opt::optimize(&program);
+    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
         .map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -4,7 +4,7 @@
 use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
-use tish_ast::{ExportDeclaration, Expr, ImportSpecifier, Program, Statement};
+use tishlang_ast::{ExportDeclaration, Expr, ImportSpecifier, Program, Statement};
 
 /// A resolved module: virtual path and its parsed program.
 #[derive(Debug, Clone)]
@@ -150,7 +150,7 @@ fn load_module_recursive(
     let source = files.get(module_path).ok_or_else(|| {
         format!("Module '{}' not in virtual file map", module_path)
     })?;
-    let program = tish_parser::parse(source.trim())
+    let program = tishlang_parser::parse(source.trim())
         .map_err(|e| format!("Parse error in {}: {}", module_path, e))?;
 
     let from_dir = parent_dir(module_path);
@@ -374,7 +374,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                             ImportSpecifier::Namespace(ns) => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
-                                    props.push(tish_ast::ObjectProp::KeyValue(
+                                    props.push(tishlang_ast::ObjectProp::KeyValue(
                                         Arc::from(k.clone()),
                                         Expr::Ident {
                                             name: Arc::from(v.clone()),

package/crates/tish_core/Cargo.toml

@@ -1,8 +1,10 @@
 [package]
-name = "tish_core"
+name = "tishlang_core"
 version = "0.1.0"
 edition = "2021"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
 regex = ["dep:fancy-regex"]

package/crates/tish_core/src/lib.rs

@@ -1,7 +1,7 @@
 //! Tish Core - Shared types and utilities for the Tish language.
 //!
 //! This crate provides the unified Value type and utilities used by both
-//! the interpreter (tish_eval) and compiled runtime (tish_runtime).
+//! the interpreter (tishlang_eval) and compiled runtime (tishlang_runtime).
 
 mod console_style;
 mod json;

package/crates/tish_core/src/macros.rs

@@ -8,7 +8,7 @@
 /// # Example
 ///
 /// ```ignore
-/// use tish_core::{tish_module, Value};
+/// use tishlang_core::{tish_module, Value};
 ///
 /// pub fn my_object() -> Value {
 ///     tish_module! {

package/crates/tish_core/src/value.rs

@@ -151,7 +151,7 @@ pub enum Value {
     Function(NativeFn),
     #[cfg(feature = "regex")]
     RegExp(Rc<RefCell<TishRegExp>>),
-    /// Promise (for native compile). Interpreter uses tish_eval::Value::Promise.
+    /// Promise (for native compile). Interpreter uses tishlang_eval::Value::Promise.
     Promise(Arc<dyn TishPromise>),
     /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
     Opaque(Arc<dyn TishOpaque>),

package/crates/tish_cranelift/Cargo.toml

@@ -1,11 +1,13 @@
 [package]
-name = "tish_cranelift"
+name = "tishlang_cranelift"
 version = "0.1.0"
 edition = "2021"
 description = "Bytecode to native via Cranelift"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [dependencies]
-tish_build_utils = { path = "../tish_build_utils" }
+tishlang_build_utils = { path = "../tish_build_utils" }
 cranelift = "0.130"
 cranelift-codegen = "0.130"
 cranelift-frontend = "0.130"
@@ -13,5 +15,5 @@ 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" }
+tishlang_bytecode = { path = "../tish_bytecode" }
+tishlang_core = { path = "../tish_core" }

package/crates/tish_cranelift/src/lib.rs

@@ -9,7 +9,7 @@ pub use link::link_to_binary;
 
 use std::path::Path;
 
-use tish_bytecode::Chunk;
+use tishlang_bytecode::Chunk;
 
 /// Error from Cranelift compilation.
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl std::fmt::Display for CraneliftError {
 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).
+/// `features` are passed to tishlang_cranelift_runtime (e.g. fs, process, http for built-in modules).
 pub fn compile_chunk_to_native(
     chunk: &Chunk,
     output_path: &Path,

package/crates/tish_cranelift/src/link.rs

@@ -12,14 +12,14 @@ pub fn link_to_binary(
     output_path: &Path,
     features: &[String],
 ) -> Result<(), CraneliftError> {
-    let workspace_root = tish_build_utils::find_workspace_root().map_err(|e| CraneliftError {
+    let workspace_root = tishlang_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)
+    let build_dir = tishlang_build_utils::create_build_dir("tishlang_cranelift_build", out_name)
         .map_err(|e| CraneliftError { message: e })?;
 
     let object_path_str = object_path
@@ -31,13 +31,13 @@ pub fn link_to_binary(
         .to_string()
         .replace('\\', "/");
 
-    // tish_cranelift_runtime path (workspace/crates/tish_cranelift_runtime)
+    // tishlang_cranelift_runtime crate lives in 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),
+            message: format!("Cannot find tishlang_cranelift_runtime: {}", e),
         })?
         .display()
         .to_string()
@@ -57,7 +57,7 @@ pub fn link_to_binary(
     };
     let cargo_toml_fixed = format!(
         r#"[package]
-name = "tish_cranelift_out"
+name = "tishlang_cranelift_out"
 version = "0.1.0"
 edition = "2021"
 
@@ -66,7 +66,7 @@ name = "{}"
 path = "src/main.rs"
 
 [dependencies]
-tish_cranelift_runtime = {{ path = {:?}{} }}
+tishlang_cranelift_runtime = {{ path = {:?}{} }}
 "#,
         out_name, runtime_path, features_str
     );
@@ -80,7 +80,7 @@ extern "C" {
 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);
+    let exit_code = tishlang_cranelift_runtime::tish_run_chunk(ptr, len);
     std::process::exit(exit_code);
 }
 "#;
@@ -104,14 +104,14 @@ fn main() {{
         message: format!("Cannot write build.rs: {}", e),
     })?;
 
-    tish_build_utils::run_cargo_build(&build_dir, None).map_err(|e| CraneliftError { message: e })?;
+    tishlang_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)
+        tishlang_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)
+    let target = tishlang_build_utils::resolve_output_path(output_path, out_name);
+    tishlang_build_utils::copy_binary_to_output(&binary, &target)
         .map_err(|e| CraneliftError { message: e })?;
 
     Ok(())

package/crates/tish_cranelift/src/lower.rs

@@ -1,7 +1,7 @@
 //! 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.
+//! The link step builds a Rust binary that reads these and runs via tishlang_vm.
 
 use std::path::Path;
 
@@ -10,7 +10,7 @@ use cranelift::codegen::settings;
 use cranelift_module::{DataDescription, Linkage, Module};
 use cranelift_object::{ObjectBuilder, ObjectModule};
 
-use tish_bytecode::{serialize, Chunk};
+use tishlang_bytecode::{serialize, Chunk};
 
 use crate::CraneliftError;
 
@@ -28,7 +28,7 @@ pub fn lower_and_emit(chunk: &Chunk, object_path: &Path) -> Result<(), Cranelift
         message: format!("Failed to finish ISA: {}", e),
     })?;
 
-    let object_builder = ObjectBuilder::new(isa, "tish_cranelift", cranelift_module::default_libcall_names())
+    let object_builder = ObjectBuilder::new(isa, "tishlang_cranelift", cranelift_module::default_libcall_names())
         .map_err(|e| CraneliftError {
             message: format!("Failed to create ObjectBuilder: {}", e),
         })?;

package/crates/tish_cranelift_runtime/Cargo.toml

@@ -1,19 +1,21 @@
 [package]
-name = "tish_cranelift_runtime"
+name = "tishlang_cranelift_runtime"
 version = "0.1.0"
 edition = "2021"
 description = "Runtime for Cranelift-compiled Tish bytecode"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
-fs = ["tish_vm/fs"]
-process = ["tish_vm/process"]
-http = ["tish_vm/http"]
+fs = ["tishlang_vm/fs"]
+process = ["tishlang_vm/process"]
+http = ["tishlang_vm/http"]
 
 [lib]
 crate-type = ["staticlib", "rlib"]
 
 [dependencies]
-tish_bytecode = { path = "../tish_bytecode" }
-tish_vm = { path = "../tish_vm" }
-tish_core = { path = "../tish_core" }
+tishlang_bytecode = { path = "../tish_bytecode" }
+tishlang_vm = { path = "../tish_vm" }
+tishlang_core = { path = "../tish_core" }

package/crates/tish_cranelift_runtime/src/lib.rs

@@ -2,8 +2,8 @@
 //!
 //! Provides tish_run_chunk(ptr, len) which deserializes and runs bytecode.
 
-use tish_bytecode::deserialize;
-use tish_vm::Vm;
+use tishlang_bytecode::deserialize;
+use tishlang_vm::Vm;
 
 /// Serialization format:
 /// - u64: code len

package/crates/tish_eval/Cargo.toml

@@ -1,26 +1,28 @@
 [package]
-name = "tish_eval"
+name = "tishlang_eval"
 version = "0.1.0"
 edition = "2021"
 description = "Tish tree-walk interpreter"
 
+license-file = { workspace = true }
+repository = { workspace = true }
 [features]
 default = []
-http = ["tokio", "reqwest", "futures", "tiny_http", "tish_core/regex", "dep:tish_runtime", "tish_runtime/http"]
+http = ["tokio", "reqwest", "futures", "tiny_http", "tishlang_core/regex", "dep:tishlang_runtime", "tishlang_runtime/http"]
 fs = []
 process = []
-regex = ["dep:fancy-regex", "tish_core/regex"]
+regex = ["dep:fancy-regex", "tishlang_core/regex"]
 tokio = ["dep:tokio"]
-ws = ["dep:tish_runtime", "tish_runtime/ws"]
+ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
 [dependencies]
 rand = "0.10.0"
-tish_ast = { path = "../tish_ast" }
-tish_parser = { path = "../tish_parser" }
-tish_core = { path = "../tish_core" }
+tishlang_ast = { path = "../tish_ast" }
+tishlang_parser = { path = "../tish_parser" }
+tishlang_core = { path = "../tish_core" }
 reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream"], optional = true }
 futures = { version = "0.3.32", optional = true }
 tiny_http = { version = "0.12.0", optional = true }
 fancy-regex = { version = "0.17.0", optional = true }
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "time", "sync"], optional = true }
-tish_runtime = { path = "../tish_runtime", optional = true }
+tishlang_runtime = { path = "../tish_runtime", optional = true }