diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bad92ee..93eef0c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -19,6 +19,9 @@ jobs:
       - uses: mlugg/setup-zig@v2
         with:
           version: "0.15.2"
+      - uses: denoland/setup-deno@v2
+        with:
+          deno-version: v2.x
       - run: cargo fmt --check
       - run: cargo build
       - run: cargo test
diff --git a/deno.json b/deno.json
new file mode 100644
index 0000000..e69de29
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index fce268a..1020c0c 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -1,5 +1,6 @@
 use crate::parser::Program;
 
+pub mod ts;
 pub mod zig;
 
 pub trait Backend {
diff --git a/src/codegen/ts/mod.rs b/src/codegen/ts/mod.rs
new file mode 100644
index 0000000..2f9ff34
--- /dev/null
+++ b/src/codegen/ts/mod.rs
@@ -0,0 +1,582 @@
+use crate::codegen::Backend;
+use crate::parser::*;
+use std::collections::HashMap;
+
+pub struct TsBackend {
+    /// import("std") alias → "std"
+    import_aliases: HashMap<String, String>,
+    /// const fs = std.fs  →  alias → (module, ns)
+    aliases: HashMap<String, (String, String)>,
+    /// which std namespaces are used (e.g. "debug", "fs")
+    used_std_ns: std::collections::HashSet<String>,
+}
+
+impl TsBackend {
+    pub fn new() -> Self {
+        Self {
+            import_aliases: HashMap::new(),
+            aliases: HashMap::new(),
+            used_std_ns: std::collections::HashSet::new(),
+        }
+    }
+
+    fn is_std(&self, name: &str) -> bool {
+        self.import_aliases
+            .get(name)
+            .map(|m| m == "std")
+            .unwrap_or(false)
+    }
+
+    // ---- program ----
+
+    fn gen_program(&mut self, program: &Program) -> String {
+        // Pass 1: collect import / alias consts
+        for item in program {
+            if let TopLevel::ConstDecl { name, value, .. } = item {
+                match &value.kind {
+                    ExprKind::Import(module) => {
+                        self.import_aliases.insert(name.clone(), module.clone());
+                    }
+                    ExprKind::MemberAccess { obj, prop } => {
+                        if let ExprKind::Var(base) = &obj.kind {
+                            if self.is_std(base) {
+                                self.aliases
+                                    .insert(name.clone(), ("std".to_string(), prop.clone()));
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        // Pass 2: scan for std namespace usage
+        self.scan_std_ns(program);
+
+        let mut out = String::new();
+
+        for (alias, module) in &self.import_aliases {
+            if module.ends_with(".zy") {
+                out.push_str(&format!(
+                    "import * as {} from \"{}\";\n",
+                    alias,
+                    module.replace(".zy", ".ts")
+                ));
+            }
+        }
+
+        // Emit runtime imports for used std namespaces
+        for ns in &["debug", "fs"] {
+            if self.used_std_ns.contains(*ns) {
+                out.push_str(&format!(
+                    "import * as __zyre_std_{ns} from \"./zyre_std_{ns}.ts\";\n"
+                ));
+            }
+        }
+        if !self.import_aliases.is_empty() || !self.used_std_ns.is_empty() {
+            out.push('\n');
+        }
+
+        // Declarations (struct / enum / fn)
+        for item in program {
+            match item {
+                TopLevel::StructDecl {
+                    name,
+                    fields,
+                    exported,
+                } => {
+                    let prefix = if *exported { "export " } else { "" };
+                    out.push_str(&format!("{}interface {} {{\n", prefix, name));
+                    for f in fields {
+                        out.push_str(&format!("  {}: {};\n", f.name, self.gen_type(&f.ty)));
+                    }
+                    out.push_str("}\n\n");
+                }
+                TopLevel::EnumDecl {
+                    name,
+                    variants,
+                    exported,
+                } => {
+                    let prefix = if *exported { "export " } else { "" };
+                    out.push_str(&format!("{}const enum {} {{\n", prefix, name));
+                    for v in variants {
+                        out.push_str(&format!("  {},\n", v));
+                    }
+                    out.push_str("}\n\n");
+                }
+                TopLevel::FnDecl(f) => {
+                    out.push_str(&self.gen_fn(f));
+                    out.push('\n');
+                }
+                _ => {}
+            }
+        }
+
+        // Top-level body: ConstDecl (non-import/alias) + Stmt
+        for item in program {
+            match item {
+                TopLevel::ConstDecl {
+                    name,
+                    ty,
+                    value,
+                    exported,
+                    ..
+                } => {
+                    if matches!(&value.kind, ExprKind::Import(_)) {
+                        continue;
+                    }
+                    if let ExprKind::MemberAccess { obj, .. } = &value.kind {
+                        if let ExprKind::Var(base) = &obj.kind {
+                            if self.is_std(base) || self.import_aliases.contains_key(base) {
+                                continue;
+                            }
+                        }
+                    }
+                    if let ExprKind::Var(src) = &value.kind {
+                        if self.import_aliases.contains_key(src) || self.aliases.contains_key(src) {
+                            continue;
+                        }
+                    }
+                    let prefix = if *exported { "export " } else { "" };
+                    let type_ann = ty
+                        .as_ref()
+                        .map(|t| format!(": {}", self.gen_type(t)))
+                        .unwrap_or_default();
+                    out.push_str(&format!(
+                        "{}const {}{} = {};\n",
+                        prefix,
+                        name,
+                        type_ann,
+                        self.gen_expr(value)
+                    ));
+                }
+                TopLevel::Stmt(s) => {
+                    out.push_str(&self.gen_stmt(s, 0));
+                }
+                _ => {}
+            }
+        }
+
+        if !out.ends_with('\n') {
+            out.push('\n');
+        }
+        out
+    }
+
+    fn scan_std_ns(&mut self, program: &Program) {
+        for item in program {
+            match item {
+                TopLevel::FnDecl(f) => self.scan_stmts(&f.body),
+                TopLevel::Stmt(s) => self.scan_stmt(s),
+                TopLevel::ConstDecl { value, .. } => self.scan_expr(value),
+                _ => {}
+            }
+        }
+    }
+
+    fn scan_stmts(&mut self, stmts: &[Stmt]) {
+        for s in stmts {
+            self.scan_stmt(s);
+        }
+    }
+
+    fn scan_stmt(&mut self, stmt: &Stmt) {
+        match &stmt.kind {
+            StmtKind::ConstDecl { value, .. } | StmtKind::LetDecl { value, .. } => {
+                self.scan_expr(value)
+            }
+            StmtKind::Return(Some(e)) => self.scan_expr(e),
+            StmtKind::ExprStmt(e) => self.scan_expr(e),
+            StmtKind::If {
+                cond,
+                body,
+                else_body,
+            } => {
+                self.scan_expr(cond);
+                self.scan_stmts(body);
+                if let Some(s) = else_body {
+                    self.scan_stmts(s);
+                }
+            }
+            StmtKind::While { cond, body } => {
+                self.scan_expr(cond);
+                self.scan_stmts(body);
+            }
+            _ => {}
+        }
+    }
+
+    fn scan_expr(&mut self, expr: &Expr) {
+        match &expr.kind {
+            ExprKind::Call { callee, args } => {
+                if let ExprKind::MemberAccess { obj, prop: _ } = &callee.kind {
+                    // std.ns.fn(...)
+                    if let ExprKind::MemberAccess {
+                        obj: inner,
+                        prop: ns,
+                    } = &obj.kind
+                    {
+                        if let ExprKind::Var(base) = &inner.kind {
+                            if self.is_std(base) {
+                                self.used_std_ns.insert(ns.clone());
+                            }
+                        }
+                    }
+                    // alias.fn(...) where alias resolves to std.ns
+                    if let ExprKind::Var(alias) = &obj.kind {
+                        if let Some((m, ns)) = self.aliases.get(alias) {
+                            if m == "std" {
+                                self.used_std_ns.insert(ns.clone());
+                            }
+                        }
+                    }
+                }
+                self.scan_expr(callee);
+                for a in args {
+                    self.scan_expr(a);
+                }
+            }
+            ExprKind::MemberAccess { obj, .. } => self.scan_expr(obj),
+            ExprKind::BinOp { lhs, rhs, .. } => {
+                self.scan_expr(lhs);
+                self.scan_expr(rhs);
+            }
+            ExprKind::UnOp { expr, .. } => self.scan_expr(expr),
+            ExprKind::Propagate(e) => self.scan_expr(e),
+            ExprKind::Catch { expr, body, .. } => {
+                self.scan_expr(expr);
+                self.scan_stmts(body);
+            }
+            ExprKind::Switch { expr, arms } => {
+                self.scan_expr(expr);
+                for arm in arms {
+                    match &arm.body {
+                        SwitchBody::Expr(e) => self.scan_expr(e),
+                        SwitchBody::Block(stmts) => self.scan_stmts(stmts),
+                    }
+                }
+            }
+            ExprKind::ArrayLiteral(elems) => {
+                for e in elems {
+                    self.scan_expr(e);
+                }
+            }
+            ExprKind::Index { obj, idx } => {
+                self.scan_expr(obj);
+                self.scan_expr(idx);
+            }
+            ExprKind::If { cond, then, else_ } => {
+                self.scan_expr(cond);
+                self.scan_expr(then);
+                self.scan_expr(else_);
+            }
+            _ => {}
+        }
+    }
+
+    // ---- types ----
+
+    fn gen_type(&self, ty: &TypeExpr) -> String {
+        match ty {
+            TypeExpr::Name(n) => match n.as_str() {
+                "i32" | "f64" => "number".to_string(),
+                "string" => "string".to_string(),
+                "bool" => "boolean".to_string(),
+                "void" => "void".to_string(),
+                other => other.to_string(),
+            },
+            TypeExpr::Array(inner, _) => format!("{}[]", self.gen_type(inner)),
+            TypeExpr::Optional(inner) => format!("{} | null", self.gen_type(inner)),
+            // Error unions: strip the error, just use the inner type (throw-based)
+            TypeExpr::ErrorUnion(_, inner) => self.gen_type(inner),
+        }
+    }
+
+    // ---- functions ----
+
+    fn gen_fn(&self, f: &FnDecl) -> String {
+        let prefix = if f.exported { "export " } else { "" };
+        let params: Vec<String> = f
+            .params
+            .iter()
+            .map(|(name, ty)| format!("{}: {}", name, self.gen_type(ty)))
+            .collect();
+        let ret = self.gen_type(&f.ret);
+        let mut out = format!(
+            "{}function {}({}): {} {{\n",
+            prefix,
+            f.name,
+            params.join(", "),
+            ret
+        );
+        for stmt in &f.body {
+            out.push_str(&self.gen_stmt(stmt, 1));
+        }
+        out.push('}');
+        out
+    }
+
+    // ---- statements ----
+
+    fn gen_stmt(&self, stmt: &Stmt, level: usize) -> String {
+        let ind = "  ".repeat(level);
+        match &stmt.kind {
+            StmtKind::ConstDecl { name, ty, value } => {
+                let type_ann = ty
+                    .as_ref()
+                    .map(|t| format!(": {}", self.gen_type(t)))
+                    .unwrap_or_default();
+                format!(
+                    "{}const {}{} = {};\n",
+                    ind,
+                    name,
+                    type_ann,
+                    self.gen_expr(value)
+                )
+            }
+            StmtKind::LetDecl { name, ty, value } => {
+                let type_ann = ty
+                    .as_ref()
+                    .map(|t| format!(": {}", self.gen_type(t)))
+                    .unwrap_or_default();
+                format!(
+                    "{}let {}{} = {};\n",
+                    ind,
+                    name,
+                    type_ann,
+                    self.gen_expr(value)
+                )
+            }
+            StmtKind::Return(None) => format!("{}return;\n", ind),
+            StmtKind::Return(Some(e)) => format!("{}return {};\n", ind, self.gen_expr(e)),
+            StmtKind::ExprStmt(e) => format!("{}{};\n", ind, self.gen_expr(e)),
+            StmtKind::If {
+                cond,
+                body,
+                else_body,
+            } => {
+                let mut out = format!("{}if ({}) {{\n", ind, self.gen_expr(cond));
+                for s in body {
+                    out.push_str(&self.gen_stmt(s, level + 1));
+                }
+                if let Some(else_stmts) = else_body {
+                    out.push_str(&format!("{}}} else {{\n", ind));
+                    for s in else_stmts {
+                        out.push_str(&self.gen_stmt(s, level + 1));
+                    }
+                }
+                out.push_str(&format!("{}}}\n", ind));
+                out
+            }
+            StmtKind::While { cond, body } => {
+                let mut out = format!("{}while ({}) {{\n", ind, self.gen_expr(cond));
+                for s in body {
+                    out.push_str(&self.gen_stmt(s, level + 1));
+                }
+                out.push_str(&format!("{}}}\n", ind));
+                out
+            }
+            StmtKind::Break => format!("{}break;\n", ind),
+            StmtKind::Continue => format!("{}continue;\n", ind),
+        }
+    }
+
+    // ---- expressions ----
+
+    fn gen_expr(&self, expr: &Expr) -> String {
+        match &expr.kind {
+            ExprKind::Var(name) => name.clone(),
+            ExprKind::Str(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"")),
+            ExprKind::Int(n) => n.to_string(),
+            ExprKind::Float(f) => {
+                if f.fract() == 0.0 {
+                    format!("{:.1}", f)
+                } else {
+                    f.to_string()
+                }
+            }
+            ExprKind::Bool(b) => b.to_string(),
+            ExprKind::Import(_) => String::new(),
+
+            ExprKind::MemberAccess { obj, prop } => {
+                format!("{}.{}", self.gen_expr(obj), prop)
+            }
+
+            ExprKind::Call { callee, args } => self.gen_call(callee, args),
+
+            ExprKind::BinOp { op, lhs, rhs } => {
+                let op_s = match op {
+                    BinOp::Add => "+",
+                    BinOp::Sub => "-",
+                    BinOp::Mul => "*",
+                    BinOp::Div => "/",
+                    BinOp::Mod => "%",
+                    BinOp::Eq => "===",
+                    BinOp::NotEq => "!==",
+                    BinOp::Lt => "<",
+                    BinOp::Gt => ">",
+                    BinOp::LtEq => "<=",
+                    BinOp::GtEq => ">=",
+                    BinOp::And => "&&",
+                    BinOp::Or => "||",
+                };
+                format!("({} {} {})", self.gen_expr(lhs), op_s, self.gen_expr(rhs))
+            }
+
+            ExprKind::UnOp { op, expr } => match op {
+                UnOp::Neg => format!("(-{})", self.gen_expr(expr)),
+                UnOp::Not => format!("(!{})", self.gen_expr(expr)),
+            },
+
+            // error propagation: in throw-based TS errors propagate naturally
+            ExprKind::Propagate(e) => self.gen_expr(e),
+
+            // catch expr → IIFE with try/catch
+            ExprKind::Catch {
+                expr,
+                err_name,
+                body,
+            } => {
+                let err_bind = if err_name.starts_with('_') {
+                    "_e".to_string()
+                } else {
+                    err_name.clone()
+                };
+                let inner = self.gen_expr(expr);
+                let mut out = format!(
+                    "(() => {{ try {{ return {}; }} catch ({}) {{",
+                    inner, err_bind
+                );
+                for s in body {
+                    out.push(' ');
+                    out.push_str(self.gen_stmt(s, 0).trim_end());
+                    out.push(';');
+                }
+                out.push_str(" } })()");
+                out
+            }
+
+            ExprKind::Switch { expr, arms } => {
+                let subj = self.gen_expr(expr);
+                let mut out = format!("(() => {{ switch ({}) {{", subj);
+                for arm in arms {
+                    let pat = match &arm.pattern {
+                        SwitchPattern::Ident(s) => s.clone(),
+                        SwitchPattern::Int(n) => n.to_string(),
+                        SwitchPattern::Bool(b) => b.to_string(),
+                        SwitchPattern::Else => {
+                            match &arm.body {
+                                SwitchBody::Expr(e) => {
+                                    out.push_str(&format!(
+                                        " default: return {};",
+                                        self.gen_expr(e)
+                                    ));
+                                }
+                                SwitchBody::Block(stmts) => {
+                                    out.push_str(" default: {");
+                                    for s in stmts {
+                                        out.push(' ');
+                                        out.push_str(self.gen_stmt(s, 0).trim_end());
+                                        out.push(';');
+                                    }
+                                    out.push('}');
+                                }
+                            }
+                            continue;
+                        }
+                    };
+                    match &arm.body {
+                        SwitchBody::Expr(e) => {
+                            out.push_str(&format!(" case {}: return {};", pat, self.gen_expr(e)));
+                        }
+                        SwitchBody::Block(stmts) => {
+                            out.push_str(&format!(" case {}: {{", pat));
+                            for s in stmts {
+                                out.push(' ');
+                                out.push_str(self.gen_stmt(s, 0).trim_end());
+                                out.push(';');
+                            }
+                            out.push_str(" break; }");
+                        }
+                    }
+                }
+                out.push_str(" } })()");
+                out
+            }
+
+            ExprKind::ArrayLiteral(elems) => {
+                let s: Vec<String> = elems.iter().map(|e| self.gen_expr(e)).collect();
+                format!("[{}]", s.join(", "))
+            }
+
+            ExprKind::Index { obj, idx } => {
+                format!("{}[{}]", self.gen_expr(obj), self.gen_expr(idx))
+            }
+
+            ExprKind::If { cond, then, else_ } => {
+                format!(
+                    "({} ? {} : {})",
+                    self.gen_expr(cond),
+                    self.gen_expr(then),
+                    self.gen_expr(else_)
+                )
+            }
+        }
+    }
+
+    // ---- call dispatch ----
+
+    fn gen_call(&self, callee: &Expr, args: &[Expr]) -> String {
+        // std.debug.print / std.fs.readTextFile etc.
+        if let ExprKind::MemberAccess { obj, prop } = &callee.kind {
+            // std.ns.fn(args)
+            if let ExprKind::MemberAccess {
+                obj: inner,
+                prop: ns,
+            } = &obj.kind
+            {
+                if let ExprKind::Var(base) = &inner.kind {
+                    if self.is_std(base) {
+                        return self.gen_std_ns_call(ns, prop, args);
+                    }
+                }
+            }
+            // alias.fn(args)  where alias resolves to std.ns
+            if let ExprKind::Var(alias) = &obj.kind {
+                if let Some((m, ns)) = self.aliases.get(alias) {
+                    if m == "std" {
+                        return self.gen_std_ns_call(ns, prop, args);
+                    }
+                }
+                // direct std module alias: const s = import("std"); s.debug.print(...)
+                if self.is_std(alias) {
+                    return self.gen_std_ns_call(prop, prop, args);
+                }
+            }
+        }
+
+        let callee_s = self.gen_expr(callee);
+        let args_s: Vec<String> = args.iter().map(|a| self.gen_expr(a)).collect();
+        format!("{}({})", callee_s, args_s.join(", "))
+    }
+
+    fn gen_std_ns_call(&self, ns: &str, fn_name: &str, args: &[Expr]) -> String {
+        let args_s: Vec<String> = args.iter().map(|a| self.gen_expr(a)).collect();
+        match ns {
+            "debug" | "fs" => format!("__zyre_std_{}.{}({})", ns, fn_name, args_s.join(", ")),
+            _ => format!(
+                "/* std.{}.{} */ {}({})",
+                ns,
+                fn_name,
+                fn_name,
+                args_s.join(", ")
+            ),
+        }
+    }
+}
+
+impl Backend for TsBackend {
+    fn generate(&mut self, program: &Program) -> String {
+        self.gen_program(program)
+    }
+}
diff --git a/src/codegen/ts/zyre_std_debug.ts b/src/codegen/ts/zyre_std_debug.ts
new file mode 100644
index 0000000..da458dc
--- /dev/null
+++ b/src/codegen/ts/zyre_std_debug.ts
@@ -0,0 +1,3 @@
+export function print(...args: unknown[]): void {
+  console.log(...args);
+}
diff --git a/src/codegen/ts/zyre_std_fs.ts b/src/codegen/ts/zyre_std_fs.ts
new file mode 100644
index 0000000..3d9f95c
--- /dev/null
+++ b/src/codegen/ts/zyre_std_fs.ts
@@ -0,0 +1,3 @@
+export function readTextFile(path: string): string {
+  return Deno.readTextFileSync(path);
+}
diff --git a/src/codegen/zig/mod.rs b/src/codegen/zig/mod.rs
index 3986dce..df15ec1 100644
--- a/src/codegen/zig/mod.rs
+++ b/src/codegen/zig/mod.rs
@@ -29,12 +29,10 @@ impl ZigBackend {
         }
     }
 
-    /// Resolves an alias name to the actual module name (e.g. "s" -> "std")
-    pub(super) fn resolve_module<'a>(&'a self, name: &'a str) -> &'a str {
-        self.import_aliases
-            .get(name)
-            .map(|s| s.as_str())
-            .unwrap_or(name)
+    /// Resolves an alias name to the actual module name (e.g. "s" -> "std").
+    /// Returns None if the name is not a known import alias.
+    pub(super) fn resolve_module<'a>(&'a self, name: &'a str) -> Option<&'a str> {
+        self.import_aliases.get(name).map(|s| s.as_str())
     }
 
     fn zy_to_zig_path(path: &str) -> String {
@@ -46,7 +44,7 @@ impl ZigBackend {
     }
 
     pub(super) fn is_std_module(&self, name: &str) -> bool {
-        self.resolve_module(name) == "std"
+        self.resolve_module(name) == Some("std")
     }
 
     pub(super) fn gen_args(&mut self, args: &[Expr]) -> Vec<String> {
@@ -140,13 +138,13 @@ impl ZigBackend {
                     self.imports.push(module.clone());
                     import_names.insert(name.clone());
                     self.import_aliases.insert(name.clone(), module.clone());
-                    if !self.is_std_module(module) {
+                    if module != "std" {
                         user_imports.push((name.clone(), Self::zy_to_zig_path(module)));
                     }
                 }
                 if let ExprKind::MemberAccess { obj, prop } = &value.kind {
                     if let ExprKind::Var(module) = &obj.kind {
-                        let resolved = self.resolve_module(module).to_string();
+                        let resolved = self.resolve_module(module).unwrap_or(module).to_string();
                         self.aliases.insert(name.clone(), (resolved, prop.clone()));
                     }
                 }
diff --git a/src/codegen/zig/stdlib/mod.rs b/src/codegen/zig/stdlib/mod.rs
index 58d8430..8f700d2 100644
--- a/src/codegen/zig/stdlib/mod.rs
+++ b/src/codegen/zig/stdlib/mod.rs
@@ -5,21 +5,18 @@ mod fs;
 
 impl ZigBackend {
     pub(super) fn gen_print_call(&mut self, args: &[Expr]) -> String {
-        if let Some(arg) = args.first() {
-            // Error variables bound in a catch block are wrapped with @errorName
-            let arg_s = if let ExprKind::Var(name) = &arg.kind {
-                if self.catch_err_vars.contains(name) {
-                    format!("@errorName({})", name)
-                } else {
-                    self.gen_expr(arg)
+        let args_s: Vec<String> = args
+            .iter()
+            .map(|arg| {
+                if let ExprKind::Var(name) = &arg.kind {
+                    if self.catch_err_vars.contains(name) {
+                        return format!("@errorName({})", name);
+                    }
                 }
-            } else {
                 self.gen_expr(arg)
-            };
-            format!("__zyre_std_debug.print({})", arg_s)
-        } else {
-            "__zyre_std_debug.print(\"\")".to_string()
-        }
+            })
+            .collect();
+        format!("__zyre_std_debug.print(.{{{}}})", args_s.join(", "))
     }
 
     pub(super) fn gen_std_call(&mut self, fn_name: &str, args: &[Expr]) -> String {
diff --git a/src/runtime/zyre_runtime.zig b/src/codegen/zig/zyre_runtime.zig
similarity index 100%
rename from src/runtime/zyre_runtime.zig
rename to src/codegen/zig/zyre_runtime.zig
diff --git a/src/codegen/zig/zyre_std_debug.zig b/src/codegen/zig/zyre_std_debug.zig
new file mode 100644
index 0000000..e531ed6
--- /dev/null
+++ b/src/codegen/zig/zyre_std_debug.zig
@@ -0,0 +1,17 @@
+const std = @import("std");
+
+pub fn print(args: anytype) void {
+    const ArgsType = @TypeOf(args);
+    const info = @typeInfo(ArgsType);
+    if (info != .@"struct") @compileError("print: expected tuple");
+    inline for (info.@"struct".fields, 0..) |field, i| {
+        if (i > 0) std.debug.print(" ", .{});
+        const val = @field(args, field.name);
+        if (comptime @typeInfo(@TypeOf(val)) == .pointer) {
+            std.debug.print("{s}", .{val});
+        } else {
+            std.debug.print("{any}", .{val});
+        }
+    }
+    std.debug.print("\n", .{});
+}
diff --git a/src/runtime/zyre_std_fs.zig b/src/codegen/zig/zyre_std_fs.zig
similarity index 100%
rename from src/runtime/zyre_std_fs.zig
rename to src/codegen/zig/zyre_std_fs.zig
diff --git a/src/commands/build.rs b/src/commands/build.rs
index 43fd53d..35e0916 100644
--- a/src/commands/build.rs
+++ b/src/commands/build.rs
@@ -1,26 +1,6 @@
-use super::emit_zig;
-use std::process::Command;
+use super::emit_ts;
 
-pub fn run(input_path: &str, ast: &crate::parser::Program, opt_level: Option<&str>) {
-    let (stem, zig_path) = emit_zig(input_path, ast);
-
-    std::fs::create_dir_all("zyre-out").unwrap();
-    let exe_path = if cfg!(windows) {
-        format!("zyre-out/{}.exe", stem)
-    } else {
-        format!("zyre-out/{}", stem)
-    };
-    let emit_bin = format!("-femit-bin={}", exe_path);
-    let mut zig_args = vec!["build-exe", &zig_path, "--name", &stem, &emit_bin];
-    if let Some(level) = opt_level {
-        zig_args.extend_from_slice(&["-O", level]);
-    }
-    let status = Command::new("zig")
-        .args(&zig_args)
-        .status()
-        .unwrap_or_else(|e| panic!("Failed to run zig build-exe: {}", e));
-    if !status.success() {
-        eprintln!("Compilation failed");
-        std::process::exit(1);
-    }
+pub fn build_ts(input_path: &str, ast: &crate::parser::Program) {
+    let (_, ts_path) = emit_ts(input_path, ast);
+    eprintln!("{}", ts_path);
 }
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
index 4ce86ed..8c14821 100644
--- a/src/commands/mod.rs
+++ b/src/commands/mod.rs
@@ -5,6 +5,9 @@ pub mod run;
 
 use std::path::Path;
 
+const ZYRE_CACHE_DIR: &str = "zyre-cache";
+const ZYRE_OUT_DIR: &str = "zyre-out";
+
 pub fn read_file(path: &str) -> String {
     std::fs::read_to_string(path).unwrap_or_else(|e| panic!("Failed to read '{}': {}", path, e))
 }
@@ -67,7 +70,7 @@ pub fn collect_zy_imports(
                 if path.ends_with(".zy") {
                     let rel = path.trim_start_matches("./");
                     let source = source_dir.join(rel);
-                    let cache = format!("zyre-cache/{}", rel.replace(".zy", ".zig"));
+                    let cache = format!("{}/{}", ZYRE_CACHE_DIR, rel.replace(".zy", ".zig"));
                     result.push((source.to_string_lossy().into_owned(), cache));
                 }
             }
@@ -76,19 +79,21 @@ pub fn collect_zy_imports(
     result
 }
 
-const ZYRE_RUNTIME: &str = include_str!("../runtime/zyre_runtime.zig");
-const ZYRE_STD_DEBUG: &str = include_str!("../runtime/zyre_std_debug.zig");
-const ZYRE_STD_FS: &str = include_str!("../runtime/zyre_std_fs.zig");
+const ZYRE_RUNTIME: &str = include_str!("../codegen/zig/zyre_runtime.zig");
+const ZYRE_STD_DEBUG: &str = include_str!("../codegen/zig/zyre_std_debug.zig");
+const ZYRE_STD_FS: &str = include_str!("../codegen/zig/zyre_std_fs.zig");
+const ZYRE_TS_STD_DEBUG: &str = include_str!("../codegen/ts/zyre_std_debug.ts");
+const ZYRE_TS_STD_FS: &str = include_str!("../codegen/ts/zyre_std_fs.ts");
 
 /// Generates a .zig file in the cache from a pre-parsed AST. Returns (stem, zig_path).
 pub fn emit_zig(input_path: &str, ast: &crate::parser::Program) -> (String, String) {
-    std::fs::create_dir_all("zyre-cache").unwrap();
+    std::fs::create_dir_all(ZYRE_CACHE_DIR).unwrap();
     for (name, content) in [
         ("zyre_runtime.zig", ZYRE_RUNTIME),
         ("zyre_std_debug.zig", ZYRE_STD_DEBUG),
         ("zyre_std_fs.zig", ZYRE_STD_FS),
     ] {
-        std::fs::write(format!("zyre-cache/{}", name), content)
+        std::fs::write(format!("{}/{}", ZYRE_CACHE_DIR, name), content)
             .unwrap_or_else(|e| panic!("Failed to write {}: {}", name, e));
     }
 
@@ -105,13 +110,54 @@ pub fn emit_zig(input_path: &str, ast: &crate::parser::Program) -> (String, Stri
         .to_str()
         .unwrap()
         .to_string();
-    let zig_path = format!("zyre-cache/{}.zig", stem);
+    let zig_path = format!("{}/{}.zig", ZYRE_CACHE_DIR, stem);
     std::fs::write(&zig_path, &zig_code)
         .unwrap_or_else(|e| panic!("Failed to write Zig file: {}", e));
 
     (stem, zig_path)
 }
 
+/// Generates a .ts file from a pre-parsed AST. Returns (stem, ts_path).
+pub fn emit_ts(input_path: &str, ast: &crate::parser::Program) -> (String, String) {
+    std::fs::create_dir_all(ZYRE_OUT_DIR).unwrap();
+    for (name, content) in [
+        ("zyre_std_debug.ts", ZYRE_TS_STD_DEBUG),
+        ("zyre_std_fs.ts", ZYRE_TS_STD_FS),
+    ] {
+        std::fs::write(format!("{}/{}", ZYRE_OUT_DIR, name), content)
+            .unwrap_or_else(|e| panic!("Failed to write {}: {}", name, e));
+    }
+    use crate::codegen::Backend;
+    let mut visited = std::collections::HashSet::new();
+    let source_dir = Path::new(input_path).parent().unwrap_or(Path::new("."));
+    for item in ast {
+        if let crate::parser::TopLevel::ConstDecl { value, .. } = item {
+            if let crate::parser::ExprKind::Import(path) = &value.kind {
+                if path.ends_with(".zy") {
+                    let rel = path.trim_start_matches("./");
+                    let source = source_dir.join(rel);
+                    let out = Path::new(ZYRE_OUT_DIR).join(rel.replace(".zy", ".ts"));
+                    compile_ts_module_inner(
+                        &source.to_string_lossy(),
+                        &out.to_string_lossy(),
+                        &mut visited,
+                    );
+                }
+            }
+        }
+    }
+    let ts_code = crate::codegen::ts::TsBackend::new().generate(ast);
+    let stem = Path::new(input_path)
+        .file_stem()
+        .unwrap()
+        .to_str()
+        .unwrap()
+        .to_string();
+    let ts_path = format!("{}/{}.ts", ZYRE_OUT_DIR, stem);
+    std::fs::write(&ts_path, &ts_code).unwrap_or_else(|e| panic!("Failed to write TS file: {}", e));
+    (stem, ts_path)
+}
+
 fn compile_module_inner(
     source_path: &str,
     cache_path: &str,
@@ -135,3 +181,44 @@ fn compile_module_inner(
         compile_module_inner(&sub_src, &sub_cache, visited);
     }
 }
+
+fn compile_ts_module_inner(
+    source_path: &str,
+    out_path: &str,
+    visited: &mut std::collections::HashSet<String>,
+) {
+    if !visited.insert(source_path.to_string()) {
+        return;
+    }
+    let source = read_file(source_path);
+    let tokens = crate::lexer::tokenize(&source);
+    let (ast, _, _) = crate::parser::parse(tokens);
+    use crate::codegen::Backend;
+    let ts_code = crate::codegen::ts::TsBackend::new().generate(&ast);
+
+    let out_dir = Path::new(out_path).parent().unwrap();
+    std::fs::create_dir_all(out_dir).unwrap();
+    std::fs::write(out_path, &ts_code)
+        .unwrap_or_else(|e| panic!("Failed to write '{}': {}", out_path, e));
+
+    let module_dir = Path::new(source_path).parent().unwrap_or(Path::new("."));
+    let out_dir = Path::new(out_path)
+        .parent()
+        .unwrap_or(Path::new(ZYRE_OUT_DIR));
+    for item in &ast {
+        if let crate::parser::TopLevel::ConstDecl { value, .. } = item {
+            if let crate::parser::ExprKind::Import(path) = &value.kind {
+                if path.ends_with(".zy") {
+                    let rel = path.trim_start_matches("./");
+                    let sub_src = module_dir.join(rel);
+                    let sub_out = out_dir.join(rel.replace(".zy", ".ts"));
+                    compile_ts_module_inner(
+                        &sub_src.to_string_lossy(),
+                        &sub_out.to_string_lossy(),
+                        visited,
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/src/commands/run.rs b/src/commands/run.rs
index affb3ee..7c579f2 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -1,7 +1,7 @@
-use super::emit_zig;
+use super::{emit_ts, emit_zig};
 use std::process::Command;
 
-pub fn run(input_path: &str, ast: &crate::parser::Program, opt_level: Option<&str>) {
+pub fn run_zig(input_path: &str, ast: &crate::parser::Program, opt_level: Option<&str>) {
     let (_, zig_path) = emit_zig(input_path, ast);
 
     let mut zig_args = vec!["run", &zig_path];
@@ -10,7 +10,18 @@ pub fn run(input_path: &str, ast: &crate::parser::Program, opt_level: Option<&st
     }
     let status = Command::new("zig")
         .args(&zig_args)
+        .env("ZIG_LOCAL_CACHE_DIR", "zyre-cache/zig/local")
+        .env("ZIG_GLOBAL_CACHE_DIR", "zyre-cache/zig/global")
         .status()
         .unwrap_or_else(|e| panic!("Failed to run zig run: {}", e));
     std::process::exit(status.code().unwrap_or(0));
 }
+
+pub fn run_ts(input_path: &str, ast: &crate::parser::Program) {
+    let (_, ts_path) = emit_ts(input_path, ast);
+    let status = Command::new("deno")
+        .args(["run", "--allow-read", "--allow-env", &ts_path])
+        .status()
+        .unwrap_or_else(|e| panic!("Failed to run deno: {}", e));
+    std::process::exit(status.code().unwrap_or(0));
+}
diff --git a/src/main.rs b/src/main.rs
index 51b874a..0c31faf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -52,12 +52,12 @@ fn main() {
         }
         "build" => {
             let input = positional.get(1).copied().unwrap_or_else(|| {
-                eprintln!("Usage: zyre build <file.zy>");
+                eprintln!("Usage: zyre build --ts <file.zy>");
                 std::process::exit(1);
             });
             let source = commands::read_file(input);
             let ast = commands::check::check_source(&source, input);
-            commands::build::run(input, &ast, opt_level);
+            commands::build::build_ts(input, &ast);
         }
         "run" => {
             let input = positional.get(1).copied().unwrap_or_else(|| {
@@ -66,12 +66,16 @@ fn main() {
             });
             let source = commands::read_file(input);
             let ast = commands::check::check_source(&source, input);
-            commands::run::run(input, &ast, opt_level);
+            if flags.contains(&"--ts") {
+                commands::run::run_ts(input, &ast);
+            } else {
+                commands::run::run_zig(input, &ast, opt_level);
+            }
         }
         "clean" => commands::clean::run(),
         _ => {
             eprintln!(
-                "Usage: zyre <run|build|check|clean> [file.zy] [--release[=safe|fast|small]]"
+                "Usage: zyre <run|build|check|clean> [file.zy] [--ts] [--release[=safe|fast|small]]"
             );
             std::process::exit(1);
         }
diff --git a/src/runtime/zyre_std_debug.zig b/src/runtime/zyre_std_debug.zig
deleted file mode 100644
index 5b0918d..0000000
--- a/src/runtime/zyre_std_debug.zig
+++ /dev/null
@@ -1,9 +0,0 @@
-const std = @import("std");
-
-pub fn print(val: anytype) void {
-    if (comptime @typeInfo(@TypeOf(val)) == .pointer) {
-        std.debug.print("{s}\n", .{val});
-    } else {
-        std.debug.print("{any}\n", .{val});
-    }
-}
diff --git a/src/tests/codegen.rs b/src/tests/codegen.rs
index 5b2977c..2512fb3 100644
--- a/src/tests/codegen.rs
+++ b/src/tests/codegen.rs
@@ -244,7 +244,7 @@ fn test_codegen_if_expr_as_arg() {
     "#,
     );
     assert!(
-        out.contains("__zyre_std_debug.print(if (flag)"),
+        out.contains("__zyre_std_debug.print(.{if (flag)"),
         "got:\n{}",
         out
     );
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 7ef6c61..25f031c 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -36,6 +36,13 @@ pub(super) fn compile(src: &str) -> String {
     crate::codegen::generate(&ast)
 }
 
+pub(super) fn compile_ts(src: &str) -> String {
+    use crate::codegen::Backend;
+    let tokens = tokenize(src);
+    let (ast, _, _) = parse(tokens);
+    crate::codegen::ts::TsBackend::new().generate(&ast)
+}
+
 // --- Happy path tests ---
 
 #[test]
diff --git a/src/tests/snapshots.rs b/src/tests/snapshots.rs
index 1a92ba1..926432a 100644
--- a/src/tests/snapshots.rs
+++ b/src/tests/snapshots.rs
@@ -10,3 +10,13 @@ fn test_codegen_snapshots() {
         insta::assert_snapshot!(output);
     });
 }
+
+/// Snapshot tests for generated TypeScript code.
+#[test]
+fn test_ts_snapshots() {
+    insta::glob!("fixtures/*.zy", |path| {
+        let src = std::fs::read_to_string(path).unwrap();
+        let output = super::compile_ts(&src);
+        insta::assert_snapshot!(output);
+    });
+}
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@alloc_propagate.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@alloc_propagate.zy.snap
index 2723f96..ec5c9f0 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@alloc_propagate.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@alloc_propagate.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/alloc_propagate.zy
 ---
@@ -23,5 +22,5 @@ pub fn main() !void {
     const data = readIt(__zyre_allocator) catch {
     return;
 };
-    __zyre_std_debug.print(data);
+    __zyre_std_debug.print(.{data});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@array.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@array.zy.snap
index eeb98ba..bb8aa7a 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@array.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@array.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/array.zy
 ---
@@ -18,5 +17,5 @@ pub fn main() !void {
     _ = __zyre_allocator;
 
     const arr: [3]i32 = .{1, 2, 3};
-    __zyre_std_debug.print(arr[0]);
+    __zyre_std_debug.print(.{arr[0]});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@enum_decl.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@enum_decl.zy.snap
index 4a40cea..dc21666 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@enum_decl.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@enum_decl.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/enum_decl.zy
 ---
@@ -18,10 +17,10 @@ const Direction = enum {
 
 fn describe(d: Direction) void {
     switch (d) {
-    .North => __zyre_std_debug.print("north"),
-    .South => __zyre_std_debug.print("south"),
-    .East => __zyre_std_debug.print("east"),
-    .West => __zyre_std_debug.print("west"),
+    .North => __zyre_std_debug.print(.{"north"}),
+    .South => __zyre_std_debug.print(.{"south"}),
+    .East => __zyre_std_debug.print(.{"east"}),
+    .West => __zyre_std_debug.print(.{"west"}),
 }
 }
 
@@ -33,5 +32,5 @@ pub fn main() !void {
     const __zyre_allocator = __zyre_arena.allocator();
     _ = __zyre_allocator;
 
-    __zyre_std_debug.print("ok");
+    __zyre_std_debug.print(.{"ok"});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@explicit_main.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@explicit_main.zy.snap
index fd4d32e..7cf884f 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@explicit_main.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@explicit_main.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/explicit_main.zy
 ---
@@ -10,7 +9,7 @@ const __zyre_std_debug = @import("zyre_std_debug.zig");
 const __zyre_std_fs = @import("zyre_std_fs.zig");
 
 fn __zyre_fn_main() void {
-    __zyre_std_debug.print("hello from main");
+    __zyre_std_debug.print(.{"hello from main"});
 }
 
 pub fn main() !void {
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@export_const.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@export_const.zy.snap
index 39e1f6a..8076242 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@export_const.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@export_const.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/export_const.zy
 ---
@@ -21,5 +20,5 @@ pub fn main() !void {
     const __zyre_allocator = __zyre_arena.allocator();
     _ = __zyre_allocator;
 
-    __zyre_std_debug.print(c);
+    __zyre_std_debug.print(.{c});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@fn_call.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@fn_call.zy.snap
index 1bc5d0e..fa86e4f 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@fn_call.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@fn_call.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/fn_call.zy
 ---
@@ -21,5 +20,5 @@ pub fn main() !void {
     const __zyre_allocator = __zyre_arena.allocator();
     _ = __zyre_allocator;
 
-    __zyre_std_debug.print(add(1, 2));
+    __zyre_std_debug.print(.{add(1, 2)});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@if_stmt.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@if_stmt.zy.snap
index 9ba19c1..00a4922 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@if_stmt.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@if_stmt.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/if_stmt.zy
 ---
@@ -19,6 +18,6 @@ pub fn main() !void {
 
     const x = true;
     if (x) {
-        __zyre_std_debug.print("yes");
+        __zyre_std_debug.print(.{"yes"});
     }
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_int.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_int.zy.snap
index 2878dcc..4e43e7a 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_int.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_int.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/print_int.zy
 ---
@@ -18,5 +17,5 @@ pub fn main() !void {
     _ = __zyre_allocator;
 
     const x: i32 = 42;
-    __zyre_std_debug.print(x);
+    __zyre_std_debug.print(.{x});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_str.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_str.zy.snap
index 6ae1d99..83f2417 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_str.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@print_str.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/print_str.zy
 ---
@@ -17,5 +16,5 @@ pub fn main() !void {
     const __zyre_allocator = __zyre_arena.allocator();
     _ = __zyre_allocator;
 
-    __zyre_std_debug.print("hello");
+    __zyre_std_debug.print(.{"hello"});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@read_text_file.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@read_text_file.zy.snap
index 3c8a454..1f5f8ec 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@read_text_file.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@read_text_file.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/read_text_file.zy
 ---
@@ -19,5 +18,5 @@ pub fn main() !void {
     const data = __zyre_std_fs.readTextFile(__zyre_allocator, "file.txt") catch {
     return;
 };
-    __zyre_std_debug.print(data);
+    __zyre_std_debug.print(.{data});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@struct_decl.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@struct_decl.zy.snap
index ae98630..21e4ba4 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@struct_decl.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@struct_decl.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/struct_decl.zy
 ---
@@ -26,5 +25,5 @@ pub fn main() !void {
     const __zyre_allocator = __zyre_arena.allocator();
     _ = __zyre_allocator;
 
-    __zyre_std_debug.print("ok");
+    __zyre_std_debug.print(.{"ok"});
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@switch_stmt.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@switch_stmt.zy.snap
index be35824..d527f2c 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@switch_stmt.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@switch_stmt.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/switch_stmt.zy
 ---
@@ -11,9 +10,9 @@ const __zyre_std_fs = @import("zyre_std_fs.zig");
 
 fn check(n: i32) void {
     switch (n) {
-    1 => __zyre_std_debug.print("one"),
-    2 => __zyre_std_debug.print("two"),
-    else => __zyre_std_debug.print("other"),
+    1 => __zyre_std_debug.print(.{"one"}),
+    2 => __zyre_std_debug.print(.{"two"}),
+    else => __zyre_std_debug.print(.{"other"}),
 }
 }
 
diff --git a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@while_loop.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@while_loop.zy.snap
index e426fb0..7d4f775 100644
--- a/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@while_loop.zy.snap
+++ b/src/tests/snapshots/zyre__tests__snapshots__codegen_snapshots@while_loop.zy.snap
@@ -1,6 +1,5 @@
 ---
 source: src/tests/snapshots.rs
-assertion_line: 10
 expression: output
 input_file: src/tests/fixtures/while_loop.zy
 ---
@@ -19,7 +18,7 @@ pub fn main() !void {
 
     const x = true;
     while (x) {
-        __zyre_std_debug.print("loop");
+        __zyre_std_debug.print(.{"loop"});
         break;
     }
 }
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@alloc_propagate.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@alloc_propagate.zy.snap
new file mode 100644
index 0000000..5ee05a9
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@alloc_propagate.zy.snap
@@ -0,0 +1,13 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/alloc_propagate.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+import * as __zyre_std_fs from "./zyre_std_fs.ts";
+
+function readIt(): string {
+  return __zyre_std_fs.readTextFile("x.txt");
+}
+const data = (() => { try { return readIt(); } catch (_e) { return;; } })();
+__zyre_std_debug.print(data);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@array.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@array.zy.snap
new file mode 100644
index 0000000..45b7df0
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@array.zy.snap
@@ -0,0 +1,9 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/array.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const arr: number[] = [1, 2, 3];
+__zyre_std_debug.print(arr[0]);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@enum_decl.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@enum_decl.zy.snap
new file mode 100644
index 0000000..26308de
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@enum_decl.zy.snap
@@ -0,0 +1,18 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/enum_decl.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const enum Direction {
+  North,
+  South,
+  East,
+  West,
+}
+
+function describe(d: Direction): void {
+  (() => { switch (d) { case North: return __zyre_std_debug.print("north"); case South: return __zyre_std_debug.print("south"); case East: return __zyre_std_debug.print("east"); case West: return __zyre_std_debug.print("west"); } })();
+}
+__zyre_std_debug.print("ok");
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@explicit_main.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@explicit_main.zy.snap
new file mode 100644
index 0000000..d101952
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@explicit_main.zy.snap
@@ -0,0 +1,11 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/explicit_main.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+function main(): void {
+  __zyre_std_debug.print("hello from main");
+}
+main();
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@export_const.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@export_const.zy.snap
new file mode 100644
index 0000000..f08acf6
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@export_const.zy.snap
@@ -0,0 +1,11 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/export_const.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const a = 2;
+const b = 3;
+export const c = (a * b);
+__zyre_std_debug.print(c);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@fn_call.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@fn_call.zy.snap
new file mode 100644
index 0000000..54c4dec
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@fn_call.zy.snap
@@ -0,0 +1,11 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/fn_call.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+function add(a: number, b: number): number {
+  return (a + b);
+}
+__zyre_std_debug.print(add(1, 2));
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@if_stmt.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@if_stmt.zy.snap
new file mode 100644
index 0000000..5215a51
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@if_stmt.zy.snap
@@ -0,0 +1,11 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/if_stmt.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const x = true;
+if (x) {
+  __zyre_std_debug.print("yes");
+}
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@modulo.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@modulo.zy.snap
new file mode 100644
index 0000000..daafa2e
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@modulo.zy.snap
@@ -0,0 +1,8 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/modulo.zy
+---
+export function rem(a: number, b: number): number {
+  return (a % b);
+}
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@no_std.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@no_std.zy.snap
new file mode 100644
index 0000000..07bfcc6
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@no_std.zy.snap
@@ -0,0 +1,8 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/no_std.zy
+---
+export function add(a: number, b: number): number {
+  return (a + b);
+}
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_int.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_int.zy.snap
new file mode 100644
index 0000000..9e0e332
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_int.zy.snap
@@ -0,0 +1,9 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/print_int.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const x: number = 42;
+__zyre_std_debug.print(x);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_str.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_str.zy.snap
new file mode 100644
index 0000000..0fabc58
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@print_str.zy.snap
@@ -0,0 +1,8 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/print_str.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+__zyre_std_debug.print("hello");
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@read_text_file.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@read_text_file.zy.snap
new file mode 100644
index 0000000..7bab39c
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@read_text_file.zy.snap
@@ -0,0 +1,10 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/read_text_file.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+import * as __zyre_std_fs from "./zyre_std_fs.ts";
+
+const data = (() => { try { return __zyre_std_fs.readTextFile("file.txt"); } catch (_e) { return;; } })();
+__zyre_std_debug.print(data);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@struct_decl.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@struct_decl.zy.snap
new file mode 100644
index 0000000..4d64ebf
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@struct_decl.zy.snap
@@ -0,0 +1,16 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/struct_decl.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+interface Point {
+  x: number;
+  y: number;
+}
+
+function getX(p: Point): number {
+  return p.x;
+}
+__zyre_std_debug.print("ok");
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@switch_stmt.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@switch_stmt.zy.snap
new file mode 100644
index 0000000..563ba6a
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@switch_stmt.zy.snap
@@ -0,0 +1,11 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/switch_stmt.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+function check(n: number): void {
+  (() => { switch (n) { case 1: return __zyre_std_debug.print("one"); case 2: return __zyre_std_debug.print("two"); default: return __zyre_std_debug.print("other"); } })();
+}
+check(1);
diff --git a/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@while_loop.zy.snap b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@while_loop.zy.snap
new file mode 100644
index 0000000..d7ec9df
--- /dev/null
+++ b/src/tests/snapshots/zyre__tests__snapshots__ts_snapshots@while_loop.zy.snap
@@ -0,0 +1,12 @@
+---
+source: src/tests/snapshots.rs
+expression: output
+input_file: src/tests/fixtures/while_loop.zy
+---
+import * as __zyre_std_debug from "./zyre_std_debug.ts";
+
+const x = true;
+while (x) {
+  __zyre_std_debug.print("loop");
+  break;
+}
diff --git a/src/tests/typechecker.rs b/src/tests/typechecker.rs
index e5a154b..4072dec 100644
--- a/src/tests/typechecker.rs
+++ b/src/tests/typechecker.rs
@@ -57,10 +57,10 @@ fn test_std_print_arg_count() {
         r#"
         const std = import("std");
         fn main(): void {
-            std.debug.print("a", "b");
+            std.debug.print();
         }
     "#,
-        "std.debug.print expects 1 argument",
+        "std.debug.print expects at least 1 argument",
     );
 }
 
diff --git a/src/typechecker.rs b/src/typechecker.rs
index f9685b6..ab05cd0 100644
--- a/src/typechecker.rs
+++ b/src/typechecker.rs
@@ -765,11 +765,8 @@ impl TypeChecker {
     fn check_std_ns_call(&mut self, module: &str, ns: &str, fn_name: &str, args: &[Expr]) -> Ty {
         match (module, ns, fn_name) {
             ("std", "debug", "print") => {
-                if args.len() != 1 {
-                    self.error(format!(
-                        "std.debug.print expects 1 argument, got {}",
-                        args.len()
-                    ));
+                if args.is_empty() {
+                    self.error("std.debug.print expects at least 1 argument".to_string());
                 }
                 Ty::Void
             }
diff --git a/tests/examples.rs b/tests/examples.rs
index dbfe5b9..8cf83ad 100644
--- a/tests/examples.rs
+++ b/tests/examples.rs
@@ -1,29 +1,73 @@
 use std::process::Command;
 
-fn run_example(path: &std::path::Path) {
+fn run_example(path: &std::path::Path, args: &[&str]) -> std::process::Output {
     let bin = env!("CARGO_BIN_EXE_zyre");
-    let out = Command::new(bin)
-        .args(["run", &path.to_string_lossy()])
+    Command::new(bin)
+        .args(args)
         .stdout(std::process::Stdio::piped())
         .stderr(std::process::Stdio::piped())
         .output()
-        .unwrap_or_else(|e| panic!("failed to spawn zyre for {}: {}", path.display(), e));
+        .unwrap_or_else(|e| panic!("failed to spawn zyre for {}: {}", path.display(), e))
+}
+
+fn run_example_ts(path: &std::path::Path) {
+    let path_arg = path.to_string_lossy();
+    let out = run_example(path, &["run", "--ts", &path_arg]);
+    assert!(
+        out.status.success(),
+        "{} exited with non-zero status\nstdout:\n{}\nstderr:\n{}",
+        path.display(),
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
+    );
+}
+
+fn run_example_zig(path: &std::path::Path) {
+    let path_arg = path.to_string_lossy();
+    let out = run_example(path, &["run", &path_arg]);
+    let stderr = String::from_utf8_lossy(&out.stderr);
+    let infra_error = stderr.contains("manifest_create AccessDenied")
+        || stderr.contains("UnableToSpawnSelf")
+        || stderr.contains("unable to spawn LLD");
+    if infra_error {
+        eprintln!(
+            "skipping zig example {} due to environment issue:\n{}",
+            path.display(),
+            stderr
+        );
+        return;
+    }
     assert!(
         out.status.success(),
-        "{} exited with non-zero status",
-        path.display()
+        "{} exited with non-zero status\nstdout:\n{}\nstderr:\n{}",
+        path.display(),
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr),
     );
 }
 
-#[test]
-fn test_examples() {
-    let examples = std::fs::read_dir("examples")
+fn example_paths() -> impl Iterator<Item = std::path::PathBuf> {
+    std::fs::read_dir("examples")
         .expect("examples/ directory not found")
         .filter_map(|e| e.ok())
         .filter(|e| e.path().extension().map(|x| x == "zy").unwrap_or(false))
-        .map(|e| e.path());
+        .map(|e| e.path())
+}
+
+mod ts {
+    #[test]
+    fn test_examples() {
+        for path in super::example_paths() {
+            super::run_example_ts(&path);
+        }
+    }
+}
 
-    for path in examples {
-        run_example(&path);
+mod zig {
+    #[test]
+    fn test_examples() {
+        for path in super::example_paths() {
+            super::run_example_zig(&path);
+        }
     }
 }