@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/js_to_tish/src/transform/stmt.rs

@@ -0,0 +1,503 @@
+//! Convert OXC statements to Tish statements.
+
+use std::sync::Arc;
+
+use oxc::ast::ast::Statement as OxcStmt;
+use oxc::semantic::Semantic;
+use tishlang_ast::{Span, Statement};
+
+use super::expr;
+use crate::error::{ConvertError, ConvertErrorKind};
+use crate::span_util;
+
+type Ctx<'a> = (&'a Semantic<'a>, &'a str);
+
+/// Convert OXC program body (statements) to Tish statements.
+pub fn convert_statements(
+    body: &[OxcStmt<'_>],
+    semantic: &Semantic<'_>,
+    source: &str,
+) -> Result<Vec<Statement>, ConvertError> {
+    let ctx = (semantic, source);
+    body.iter().map(|s| convert_statement(s, &ctx)).collect()
+}
+
+fn convert_statement(stmt: &OxcStmt<'_>, ctx: &Ctx<'_>) -> Result<Statement, ConvertError> {
+    let span = span_util::oxc_span_to_tish(ctx.1, stmt);
+    match stmt {
+        OxcStmt::BlockStatement(b) => {
+            let statements = convert_statements(&b.body, ctx.0, ctx.1)?;
+            Ok(Statement::Block { statements, span })
+        }
+        OxcStmt::VariableDeclaration(v) => convert_var_decl(v, ctx, span),
+        OxcStmt::ExpressionStatement(e) => {
+            let expr = expr::convert_expr(&e.expression, ctx)?;
+            Ok(Statement::ExprStmt { expr, span })
+        }
+        OxcStmt::IfStatement(i) => {
+            let cond = expr::convert_expr(&i.test, ctx)?;
+            let then_branch = Box::new(convert_statement(&i.consequent, ctx)?);
+            let else_branch = i
+                .alternate
+                .as_ref()
+                .map(|a| convert_statement(a, ctx))
+                .transpose()?
+                .map(Box::new);
+            Ok(Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                span,
+            })
+        }
+        OxcStmt::ReturnStatement(r) => {
+            let value = r
+                .argument
+                .as_ref()
+                .map(|a| expr::convert_expr(a, ctx))
+                .transpose()?;
+            Ok(Statement::Return { value, span })
+        }
+        OxcStmt::BreakStatement(_) => Ok(Statement::Break { span }),
+        OxcStmt::ContinueStatement(_) => Ok(Statement::Continue { span }),
+        OxcStmt::WhileStatement(w) => {
+            let cond = expr::convert_expr(&w.test, ctx)?;
+            let body = Box::new(convert_statement(&w.body, ctx)?);
+            Ok(Statement::While { cond, body, span })
+        }
+        OxcStmt::DoWhileStatement(d) => {
+            let cond = expr::convert_expr(&d.test, ctx)?;
+            let body = Box::new(convert_statement(&d.body, ctx)?);
+            Ok(Statement::DoWhile { body, cond, span })
+        }
+        OxcStmt::ForStatement(f) => convert_for_statement(f, ctx, span),
+        OxcStmt::ForOfStatement(f) => convert_for_of_statement(f, ctx, span),
+        OxcStmt::SwitchStatement(s) => convert_switch_statement(s, ctx, span),
+        OxcStmt::ThrowStatement(t) => {
+            let value = expr::convert_expr(&t.argument, ctx)?;
+            Ok(Statement::Throw { value, span })
+        }
+        OxcStmt::TryStatement(t) => convert_try_statement(t, ctx, span),
+        OxcStmt::FunctionDeclaration(f) => convert_function_decl(f, ctx, span),
+        OxcStmt::EmptyStatement(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "empty statement".into(),
+            hint: None,
+        })),
+        OxcStmt::ForInStatement(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "for-in".into(),
+            hint: Some("Tish omits for-in".into()),
+        })),
+        OxcStmt::ClassDeclaration(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "class".into(),
+            hint: Some("Tish does not support classes".into()),
+        })),
+        OxcStmt::WithStatement(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "with".into(),
+            hint: None,
+        })),
+        OxcStmt::DebuggerStatement(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "debugger".into(),
+            hint: None,
+        })),
+        OxcStmt::LabeledStatement(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "labeled statement".into(),
+            hint: None,
+        })),
+        OxcStmt::ImportDeclaration(i) => convert_import(i, ctx, span),
+        OxcStmt::ExportDefaultDeclaration(e) => convert_export_default(e, ctx, span),
+        OxcStmt::ExportNamedDeclaration(e) => convert_export_named(e, ctx, span),
+        OxcStmt::ExportAllDeclaration(_) => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "export *".into(),
+            hint: None,
+        })),
+        _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: format!("{:?}", std::mem::discriminant(stmt)),
+            hint: None,
+        })),
+    }
+}
+
+fn convert_declaration(
+    decl: &oxc::ast::ast::Declaration<'_>,
+    ctx: &Ctx<'_>,
+) -> Result<Statement, ConvertError> {
+    let span = span_util::oxc_span_to_tish(ctx.1, decl);
+    match decl {
+        oxc::ast::ast::Declaration::VariableDeclaration(v) => convert_var_decl(v, ctx, span),
+        oxc::ast::ast::Declaration::FunctionDeclaration(f) => convert_function_decl(f, ctx, span),
+        _ => Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: format!("declaration: {:?}", std::mem::discriminant(decl)),
+            hint: None,
+        })),
+    }
+}
+
+fn convert_var_decl(
+    v: &oxc::ast::ast::VariableDeclaration<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let mutable = matches!(v.kind, oxc::ast::ast::VariableDeclarationKind::Let);
+    if v.declarations.len() == 1 {
+        let d = &v.declarations[0];
+        let id = &d.id;
+        let init = d
+            .init
+            .as_ref()
+            .map(|i| expr::convert_expr(i, ctx))
+            .transpose()?;
+        match id {
+            oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
+                let name: Arc<str> = Arc::from(b.name.as_str());
+                let name_span = span_util::oxc_span_to_tish(ctx.1, b.as_ref());
+                Ok(Statement::VarDecl {
+                    name,
+                    name_span,
+                    mutable,
+                    type_ann: None,
+                    init,
+                    span,
+                })
+            }
+            _ => {
+                let init = d
+                    .init
+                    .as_ref()
+                    .map(|i| expr::convert_expr(i, ctx))
+                    .transpose()?
+                    .ok_or_else(|| {
+                        ConvertError::new(ConvertErrorKind::Incompatible {
+                            what: "destructuring declaration".into(),
+                            reason: "initializer required".into(),
+                        })
+                    })?;
+                let pattern = expr::convert_destruct_pattern(id)?;
+                Ok(Statement::VarDeclDestructure {
+                    pattern,
+                    mutable,
+                    init,
+                    span,
+                })
+            }
+        }
+    } else {
+        Err(ConvertError::new(ConvertErrorKind::Incompatible {
+            what: "multi-declarator variable declaration".into(),
+            reason: "split into separate declarations".into(),
+        }))
+    }
+}
+
+fn convert_for_statement(
+    f: &oxc::ast::ast::ForStatement<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let init = f
+        .init
+        .as_ref()
+        .map(|i| match i {
+            oxc::ast::ast::ForStatementInit::VariableDeclaration(v) => {
+                convert_var_decl(v, ctx, span_util::stub_span()).map(Box::new)
+            }
+            _ => {
+                if let Some(e) = i.as_expression() {
+                    expr::convert_expr(e, ctx).map(|expr| {
+                        Box::new(Statement::ExprStmt {
+                            expr,
+                            span: span_util::stub_span(),
+                        })
+                    })
+                } else {
+                    Err(ConvertError::new(ConvertErrorKind::Unsupported {
+                        what: "for init".into(),
+                        hint: None,
+                    }))
+                }
+            }
+        })
+        .transpose()?;
+    let cond = f
+        .test
+        .as_ref()
+        .map(|e| expr::convert_expr(e, ctx))
+        .transpose()?;
+    let update = f
+        .update
+        .as_ref()
+        .map(|e| expr::convert_expr(e, ctx))
+        .transpose()?;
+    let body = Box::new(convert_statement(&f.body, ctx)?);
+    Ok(Statement::For {
+        init,
+        cond,
+        update,
+        body,
+        span,
+    })
+}
+
+fn convert_for_of_statement(
+    f: &oxc::ast::ast::ForOfStatement<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let (name, name_span) = match &f.left {
+        oxc::ast::ast::ForStatementLeft::VariableDeclaration(v) => {
+            if v.declarations.len() == 1 {
+                let d = &v.declarations[0];
+                match &d.id {
+                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                        b.name.as_str(),
+                        span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                    ),
+                    _ => {
+                        return Err(ConvertError::new(ConvertErrorKind::Incompatible {
+                            what: "for-of with destructuring".into(),
+                            reason: "use simple identifier".into(),
+                        }))
+                    }
+                }
+            } else {
+                return Err(ConvertError::new(ConvertErrorKind::Incompatible {
+                    what: "for-of with multiple bindings".into(),
+                    reason: "not supported".into(),
+                }));
+            }
+        }
+        _ => {
+            return Err(ConvertError::new(ConvertErrorKind::Incompatible {
+                what: "for-of (use variable declaration in left)".into(),
+                reason: "e.g. for (const x of arr)".into(),
+            }))
+        }
+    };
+    let iterable = expr::convert_expr(&f.right, ctx)?;
+    let body = Box::new(convert_statement(&f.body, ctx)?);
+    Ok(Statement::ForOf {
+        name: Arc::from(name),
+        name_span,
+        iterable,
+        body,
+        span,
+    })
+}
+
+fn convert_switch_statement(
+    s: &oxc::ast::ast::SwitchStatement<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let expr = expr::convert_expr(&s.discriminant, ctx)?;
+    let mut cases = Vec::new();
+    let mut default_body: Option<Vec<Statement>> = None;
+    for c in &s.cases {
+        let stmts = convert_statements(&c.consequent, ctx.0, ctx.1)?;
+        match &c.test {
+            Some(t) => cases.push((Some(expr::convert_expr(t, ctx)?), stmts)),
+            None => default_body = Some(stmts),
+        }
+    }
+    Ok(Statement::Switch {
+        expr,
+        cases,
+        default_body,
+        span,
+    })
+}
+
+fn convert_try_statement(
+    t: &oxc::ast::ast::TryStatement<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    // TryStatement.block is BlockStatement; convert its body to Statement::Block
+    let body_stmts = convert_statements(&t.block.body, ctx.0, ctx.1)?;
+    let body = Box::new(Statement::Block {
+        statements: body_stmts,
+        span: span_util::oxc_span_to_tish(ctx.1, &*t.block),
+    });
+    let (catch_param, catch_param_span, catch_body) = match &t.handler {
+        Some(h) => {
+            let (param, pspan) = h
+                .param
+                .as_ref()
+                .and_then(|cp: &oxc::ast::ast::CatchParameter<'_>| {
+                    if let oxc::ast::ast::BindingPattern::BindingIdentifier(b) = &cp.pattern {
+                        Some((
+                            Arc::from(b.name.as_str()),
+                            span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                        ))
+                    } else {
+                        None
+                    }
+                })
+                .map_or((None, None), |(n, s)| (Some(n), Some(s)));
+            let catch_stmts = convert_statements(&h.body.body, ctx.0, ctx.1)?;
+            let cb = Box::new(Statement::Block {
+                statements: catch_stmts,
+                span: span_util::oxc_span_to_tish(ctx.1, &*h.body),
+            });
+            (param, pspan, Some(cb))
+        }
+        None => (None, None, None),
+    };
+    let finally_body = t
+        .finalizer
+        .as_ref()
+        .map(|f| {
+            let stmts = convert_statements(&f.body, ctx.0, ctx.1)?;
+            Ok(Box::new(Statement::Block {
+                statements: stmts,
+                span: span_util::oxc_span_to_tish(ctx.1, &**f),
+            }))
+        })
+        .transpose()?;
+    Ok(Statement::Try {
+        body,
+        catch_param,
+        catch_param_span,
+        catch_body,
+        finally_body,
+        span,
+    })
+}
+
+fn convert_function_decl(
+    f: &oxc::ast::ast::Function<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let async_ = f.r#async;
+    let name: Arc<str> =
+        f.id.as_ref()
+            .map(|id| Arc::from(id.name.as_str()))
+            .unwrap_or_else(|| Arc::from(""));
+    let name_span =
+        f.id.as_ref()
+            .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
+            .unwrap_or_else(span_util::stub_span);
+    let (params, rest_param) = expr::convert_params(&f.params, ctx)?;
+    let body = match &f.body {
+        Some(fb) => {
+            let stmts = convert_statements(&fb.statements, ctx.0, ctx.1)?;
+            Box::new(Statement::Block {
+                statements: stmts,
+                span: span_util::oxc_span_to_tish(ctx.1, fb.as_ref()),
+            })
+        }
+        None => {
+            return Err(ConvertError::new(ConvertErrorKind::Incompatible {
+                what: "function body".into(),
+                reason: "expected block".into(),
+            }))
+        }
+    };
+    Ok(Statement::FunDecl {
+        async_,
+        name,
+        name_span,
+        params,
+        rest_param,
+        return_type: None,
+        body,
+        span,
+    })
+}
+
+fn convert_import(
+    i: &oxc::ast::ast::ImportDeclaration<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let from: Arc<str> = Arc::from(i.source.value.as_str());
+    let mut specifiers = Vec::new();
+    if let Some(specs) = &i.specifiers {
+        for s in specs.iter() {
+            match s {
+                oxc::ast::ast::ImportDeclarationSpecifier::ImportSpecifier(is) => {
+                    let imported_name = is.imported.name().as_str();
+                    let local_name = is.local.name.as_str();
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &is.imported);
+                    let (alias, alias_span) = if imported_name == local_name {
+                        (None, None)
+                    } else {
+                        (
+                            Some(Arc::from(local_name)),
+                            Some(crate::span_util::oxc_span_to_tish(ctx.1, &is.local)),
+                        )
+                    };
+                    specifiers.push(tishlang_ast::ImportSpecifier::Named {
+                        name: Arc::from(imported_name),
+                        name_span,
+                        alias,
+                        alias_span,
+                    });
+                }
+                oxc::ast::ast::ImportDeclarationSpecifier::ImportDefaultSpecifier(ds) => {
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &ds.local);
+                    specifiers.push(tishlang_ast::ImportSpecifier::Default {
+                        name: Arc::from(ds.local.name.as_str()),
+                        name_span,
+                    });
+                }
+                oxc::ast::ast::ImportDeclarationSpecifier::ImportNamespaceSpecifier(ns) => {
+                    let name_span = crate::span_util::oxc_span_to_tish(ctx.1, &ns.local);
+                    specifiers.push(tishlang_ast::ImportSpecifier::Namespace {
+                        name: Arc::from(ns.local.name.as_str()),
+                        name_span,
+                    });
+                }
+            }
+        }
+    }
+    Ok(Statement::Import {
+        specifiers,
+        from,
+        span,
+    })
+}
+
+fn convert_export_default(
+    e: &oxc::ast::ast::ExportDefaultDeclaration<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    let declaration = if let Some(expr) = e.declaration.as_expression() {
+        let expr = expr::convert_expr(expr, ctx)?;
+        tishlang_ast::ExportDeclaration::Default(expr)
+    } else if let oxc::ast::ast::ExportDefaultDeclarationKind::FunctionDeclaration(f) =
+        &e.declaration
+    {
+        let stmt = convert_function_decl(f.as_ref(), ctx, span_util::stub_span())?;
+        tishlang_ast::ExportDeclaration::Named(Box::new(stmt))
+    } else {
+        return Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "export default (this form)".into(),
+            hint: None,
+        }));
+    };
+    Ok(Statement::Export {
+        declaration: Box::new(declaration),
+        span,
+    })
+}
+
+fn convert_export_named(
+    e: &oxc::ast::ast::ExportNamedDeclaration<'_>,
+    ctx: &Ctx<'_>,
+    span: Span,
+) -> Result<Statement, ConvertError> {
+    if let Some(decl) = &e.declaration {
+        let stmt = convert_declaration(decl, ctx)?;
+        Ok(Statement::Export {
+            declaration: Box::new(tishlang_ast::ExportDeclaration::Named(Box::new(stmt))),
+            span,
+        })
+    } else {
+        Err(ConvertError::new(ConvertErrorKind::Unsupported {
+            what: "export { ... } (re-exports)".into(),
+            hint: None,
+        }))
+    }
+}

package/crates/js_to_tish/src/transform.rs

@@ -0,0 +1,60 @@
+//! Convert OXC AST (with semantic info) to Tish AST.
+
+mod expr;
+mod stmt;
+
+use oxc::allocator::Allocator;
+use oxc::parser::Parser;
+use oxc::semantic::SemanticBuilder;
+use oxc::span::SourceType;
+use tishlang_ast::Program;
+
+use crate::error::{ConvertError, ConvertErrorKind};
+use crate::transform::stmt::convert_statements;
+
+/// Convert JavaScript source to Tish AST.
+///
+/// Performs parse, semantic analysis, normalization (var/function hoisting),
+/// and transformation to Tish AST.
+pub fn convert(js_source: &str) -> Result<Program, ConvertError> {
+    let allocator = Allocator::default();
+    let source_type = SourceType::from_path("script.js").unwrap();
+    let parser_ret = Parser::new(&allocator, js_source, source_type).parse();
+
+    if parser_ret.panicked {
+        let msg = parser_ret
+            .errors
+            .iter()
+            .map(|e| format!("{e:?}"))
+            .collect::<Vec<_>>()
+            .join("; ");
+        return Err(ConvertError::new(ConvertErrorKind::Parse(msg)));
+    }
+    if !parser_ret.errors.is_empty() {
+        let msg = parser_ret
+            .errors
+            .into_iter()
+            .map(|e| format!("{e:?}"))
+            .collect::<Vec<_>>()
+            .join("; ");
+        return Err(ConvertError::new(ConvertErrorKind::Parse(msg)));
+    }
+
+    let program = parser_ret.program;
+    let semantic_ret = SemanticBuilder::new()
+        .with_check_syntax_error(true)
+        .build(&program);
+
+    if !semantic_ret.errors.is_empty() {
+        let msg = semantic_ret
+            .errors
+            .into_iter()
+            .map(|e| format!("{e:?}"))
+            .collect::<Vec<_>>()
+            .join("; ");
+        return Err(ConvertError::new(ConvertErrorKind::Semantic(msg)));
+    }
+
+    let statements = convert_statements(&program.body, &semantic_ret.semantic, js_source)?;
+    Ok(Program { statements })
+}

package/crates/tish/Cargo.toml

@@ -0,0 +1,62 @@
+[package]
+name = "tishlang"
+version = "0.0.0-dev"
+edition = "2021"
+description = "Tish CLI - run, REPL, compile to native"
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[[bin]]
+name = "tish"
+path = "src/main.rs"
+
+[features]
+# The published `tish` CLI always includes every optional runtime (http, timers, fs, process, regex, ws).
+# Use `cargo build -p tishlang --no-default-features` when you need a locked-down toolchain
+# (see workspace `justfile`). `tish run --feature …` / `tish build --feature …` gate what runs
+# or what gets linked into a *native output* binary — they are not the primary way to ship a
+# “full” vs “empty” CLI.
+default = ["full", "fast-alloc"]
+# Alias: same dependency edges as `default` (kept for `--features full` in CI and docs).
+# Includes `pg` so `tish run` can resolve `import … from '@tishlang/pg'` (`cargo:tish_pg`) on the bytecode VM.
+full = ["http", "fs", "process", "regex", "ws", "timers", "tty", "pg"]
+# Fast allocator (mimalloc) as the process `#[global_allocator]`. tish's object/array/string workloads
+# are allocation-bound (a sampling profile of object-heavy code spends ~14%+ in system malloc/free);
+# mimalloc is markedly faster for the many-small-allocations pattern — the same reason JSC ships bmalloc.
+# Semantically transparent (just a faster malloc); `--no-default-features` drops it for the system allocator.
+fast-alloc = ["dep:mimalloc"]
+# Opt-out: build without Postgres (`cargo build -p tishlang --no-default-features --features http,...`).
+pg = ["dep:tishlang_pg"]
+# Individual capability flags
+http    = ["tishlang_eval/http",    "tishlang_runtime/http",    "tishlang_compile/http",    "tishlang_vm/http"]
+timers  = ["tishlang_eval/timers",  "tishlang_compile/timers",  "tishlang_vm/timers"]
+fs      = ["tishlang_eval/fs",      "tishlang_runtime/fs",      "tishlang_compile/fs",      "tishlang_vm/fs"]
+process = ["tishlang_eval/process", "tishlang_runtime/process", "tishlang_compile/process", "tishlang_vm/process"]
+regex   = ["tishlang_eval/regex",   "tishlang_runtime/regex",   "tishlang_compile/regex",   "tishlang_vm/regex"]
+ws      = ["tishlang_eval/ws",      "tishlang_runtime/ws",      "tishlang_compile/ws",      "tishlang_vm/ws"]
+tty     = ["tishlang_eval/tty",     "tishlang_runtime/tty",     "tishlang_compile/tty",     "tishlang_vm/tty"]
+# GPU compute — Apple Silicon only
+[dependencies]
+rustyline = { version = "17", features = ["with-file-history"] }
+tishlang_lexer = { path = "../tish_lexer", version = ">=0.1" }
+tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
+tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_eval = { path = "../tish_eval", version = ">=0.1" }
+tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
+tishlang_compile_js = { path = "../tish_compile_js", version = ">=0.1" }
+tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
+tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
+tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
+tishlang_ffi = { path = "../tish_ffi", version = ">=0.1" }
+tishlang_native = { path = "../tish_native", version = ">=0.1" }
+tishlang_llvm = { path = "../tish_llvm", version = ">=0.1" }
+tishlang_wasm = { path = "../tish_wasm", version = ">=0.1" }
+tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
+tishlang_js_to_tish = { path = "../js_to_tish", version = ">=0.1" }
+clap = { version = "4.6.0", features = ["derive", "color"] }
+tishlang_pg = { path = "../tish_pg", version = ">=0.1", optional = true }
+mimalloc = { version = "0.1", optional = true }
+
+[dev-dependencies]
+rayon = "1.11"

package/crates/tish/build.rs

@@ -0,0 +1,21 @@
+//! Export the `tish_value_*` C-ABI accessors (from `tishlang_ffi`) in the `tish` binary's dynamic
+//! symbol table, so a `dlopen`'d native extension (`ffi:`) can resolve them at load time. This is
+//! the **decoupled** FFI model: the extension declares the accessors `extern "C"` and does NOT link
+//! `tish_core`, so there is a single value representation and no host/extension layout matching.
+//! Without this flag the host's accessor symbols aren't visible to the loaded library.
+
+fn main() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    match target_os.as_str() {
+        // macOS/iOS: export all global symbols (so the two-level-namespace binary exposes them).
+        "macos" | "ios" => {
+            println!("cargo:rustc-link-arg-bins=-Wl,-export_dynamic");
+        }
+        // Windows PE export tables work differently; the host-export FFI model isn't wired there yet.
+        "windows" => {}
+        // Linux/BSD: -rdynamic puts all symbols in the dynamic table.
+        _ => {
+            println!("cargo:rustc-link-arg-bins=-rdynamic");
+        }
+    }
+}

package/crates/tish/src/cargo_native_registry.rs

@@ -0,0 +1,32 @@
+//! Registers `cargo:*` Rust shims on the bytecode VM (`tish run`, REPL).
+//!
+//! Native `tish build` outputs register their own crates at link time; the
+//! interpreter path must populate [`tishlang_vm::Vm::register_native_module`].
+
+#[cfg(feature = "pg")]
+pub(crate) fn register_bytecode_native_modules(vm: &mut tishlang_vm::Vm) {
+    use std::sync::Arc;
+    use tishlang_core::{ObjectMap, Value};
+
+    let mut om = ObjectMap::with_capacity(8);
+    om.insert(
+        Arc::from("per_worker_client"),
+        Value::native(tishlang_pg::per_worker_client),
+    );
+    om.insert(Arc::from("connect"), Value::native(tishlang_pg::connect));
+    om.insert(Arc::from("prepare"), Value::native(tishlang_pg::prepare));
+    om.insert(
+        Arc::from("query_prepared"),
+        Value::native(tishlang_pg::query_prepared),
+    );
+    om.insert(
+        Arc::from("query_all"),
+        Value::native(tishlang_pg::query_all),
+    );
+    om.insert(Arc::from("migrate"), Value::native(tishlang_pg::migrate));
+    om.insert(Arc::from("close"), Value::native(tishlang_pg::close));
+    vm.register_native_module("cargo:tish_pg", om);
+}
+
+#[cfg(not(feature = "pg"))]
+pub(crate) fn register_bytecode_native_modules(_vm: &mut tishlang_vm::Vm) {}