@tishlang/tish 1.0.29 → 1.0.33

package/Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "crates/tish_eval",
     "crates/tish_runtime",
     "crates/tish_compile",
+    "crates/tish_ui",
     "crates/tish_jsx_web",
     "crates/tish_compile_js",
     "crates/tish_bytecode",

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

@@ -6,7 +6,7 @@ use oxc::ast::ast::Expression as OxcExpr;
 use oxc::semantic::Semantic;
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, Literal, LogicalAssignOp,
-    MemberProp, ObjectProp, TypedParam,
+    FunParam, MemberProp, ObjectProp, TypedParam,
 };
 
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -73,6 +73,15 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                 .collect::<Result<Vec<_>, _>>()?;
             Ok(Expr::Call { callee, args, span })
         }
+        OxcExpr::NewExpression(n) => {
+            let callee = Box::new(convert_expr(&n.callee, ctx)?);
+            let args = n
+                .arguments
+                .iter()
+                .map(|a| convert_call_arg(a, ctx))
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(Expr::New { callee, args, span })
+        }
         OxcExpr::StaticMemberExpression(s) => {
             let object = Box::new(convert_expr(&s.object, ctx)?);
             Ok(Expr::Member {
@@ -518,7 +527,7 @@ fn convert_unary_op(
 pub fn convert_params(
     params: &oxc::ast::ast::FormalParameters<'_>,
     ctx: &Ctx<'_>,
-) -> Result<(Vec<TypedParam>, Option<TypedParam>), ConvertError> {
+) -> Result<(Vec<FunParam>, Option<TypedParam>), ConvertError> {
     let mut typed_params = Vec::new();
     let mut rest_param = None;
     for (i, p) in params.items.iter().enumerate() {
@@ -558,11 +567,11 @@ pub fn convert_params(
                     .as_ref()
                     .map(|e| convert_expr(e, ctx))
                     .transpose()?;
-                typed_params.push(TypedParam {
+                typed_params.push(FunParam::Simple(TypedParam {
                     name: Arc::from(name),
                     type_ann: None,
                     default,
-                });
+                }));
         }
     }
     if rest_param.is_none() {
@@ -589,10 +598,10 @@ pub fn convert_params(
 fn convert_arrow_params(
     params: &oxc::ast::ast::FormalParameters<'_>,
     ctx: &Ctx<'_>,
-) -> Result<Vec<TypedParam>, ConvertError> {
+) -> Result<Vec<FunParam>, ConvertError> {
     let (mut ps, rest) = convert_params(params, ctx)?;
     if let Some(r) = rest {
-        ps.push(r);
+        ps.push(FunParam::Simple(r));
     }
     Ok(ps)
 }

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.0.29"
+version = "1.0.33"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -28,7 +28,7 @@ struct RunArgs {
     #[arg(long, default_value = "vm")]
     backend: String,
     /// Enable capabilities (http, fs, process, regex, ws). Must match how tish was built.
-    /// E.g. cargo run -p tish --features http,fs -- run script.tish --feature http,fs
+    /// E.g. cargo run -p tishlang--features http,fs -- run script.tish --feature http,fs
     #[arg(long = "feature", action = clap::ArgAction::Append)]
     features: Vec<String>,
     /// Disable AST and bytecode optimizations (for debugging)

package/crates/tish/tests/integration_test.rs

@@ -1,8 +1,8 @@
 //! Full-stack integration tests: run .tish files with interpreter or each backend and compare
 //! stdout to static expected files (e.g. `fn_any.tish.expected`).
 //!
-//! - Run: `cargo test -p tish` (or `cargo nextest run -p tish`).
-//! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tish test_mvp_programs_interpreter`
+//! - Run: `cargo test -p tishlang` (or `cargo nextest run -p tishlang`).
+//! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tishlangtest_mvp_programs_interpreter`
 //!   then commit the new/updated `tests/core/*.tish.expected` files.
 //! - Compiled outputs are cached under `target/integration_compile_cache/` per backend.
 
@@ -232,7 +232,7 @@ fn test_async_await_compile_via_binary() {
 /// Uses httpbin.org/delay/1 (1s each). 3 parallel ≈ 1s, 3 sequential ≈ 3s.
 #[test]
 #[cfg(feature = "http")]
-#[ignore = "timing and network sensitive; run manually: cargo test test_async_parallel_vs_sequential_timing -p tish --features http -- --ignored"]
+#[ignore = "timing and network sensitive; run manually: cargo test test_async_parallel_vs_sequential_timing -p tishlang--features http -- --ignored"]
 fn test_async_parallel_vs_sequential_timing() {
     let bin = tish_bin();
     let parallel_src = workspace_root().join("examples").join("async-await").join("src").join("parallel.tish");
@@ -474,6 +474,7 @@ const MVP_TEST_FILES: &[&str] = &[
     "types.tish",
     "logical_assign.tish",
     "spread.tish",
+    "fn_param_destructuring.tish",
 ];
 
 /// Run each .tish file with interpreter and compare stdout to static expected.

package/crates/tish_ast/src/ast.rs

@@ -34,6 +34,62 @@ pub struct TypedParam {
     pub default: Option<Expr>,
 }
 
+
+/// Single formal parameter: simple identifier or destructuring pattern.
+#[derive(Debug, Clone, PartialEq)]
+pub enum FunParam {
+    Simple(TypedParam),
+    Destructure {
+        pattern: DestructPattern,
+        type_ann: Option<TypeAnnotation>,
+        default: Option<Expr>,
+    },
+}
+
+
+impl FunParam {
+    /// Variable names introduced by this formal parameter.
+    pub fn bound_names(&self) -> Vec<Arc<str>> {
+        let mut out = Vec::new();
+        match self {
+            FunParam::Simple(tp) => out.push(Arc::clone(&tp.name)),
+            FunParam::Destructure { pattern, .. } => {
+                Self::collect_pattern_binding_names(pattern, &mut out);
+            }
+        }
+        out
+    }
+
+    fn collect_pattern_binding_names(pattern: &DestructPattern, out: &mut Vec<Arc<str>>) {
+        match pattern {
+            DestructPattern::Array(elements) => {
+                for el in elements {
+                    if let Some(el) = el {
+                        match el {
+                            DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                            DestructElement::Pattern(p) => {
+                                Self::collect_pattern_binding_names(p, out);
+                            }
+                            DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                        }
+                    }
+                }
+            }
+            DestructPattern::Object(props) => {
+                for prop in props {
+                    match &prop.value {
+                        DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                        DestructElement::Pattern(p) => {
+                            Self::collect_pattern_binding_names(p, out);
+                        }
+                        DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// Destructuring pattern for array or object destructuring
 #[derive(Debug, Clone, PartialEq)]
 pub enum DestructPattern {
@@ -149,7 +205,7 @@ pub enum Statement {
     FunDecl {
         async_: bool,
         name: Arc<str>,
-        params: Vec<TypedParam>,
+        params: Vec<FunParam>,
         rest_param: Option<TypedParam>,
         return_type: Option<TypeAnnotation>,
         body: Box<Statement>,
@@ -214,6 +270,12 @@ pub enum Expr {
         args: Vec<CallArg>,
         span: Span,
     },
+    /// `new` expression (JavaScript target). `callee` is the constructor reference; `args` may be empty.
+    New {
+        callee: Box<Expr>,
+        args: Vec<CallArg>,
+        span: Span,
+    },
     Member {
         object: Box<Expr>,
         prop: MemberProp,
@@ -298,7 +360,7 @@ pub enum Expr {
     },
     /// Arrow function: (params) => body
     ArrowFunction {
-        params: Vec<TypedParam>,
+        params: Vec<FunParam>,
         body: ArrowBody,
         span: Span,
     },
@@ -374,6 +436,7 @@ impl Expr {
             Expr::Binary { span, .. } => *span,
             Expr::Unary { span, .. } => *span,
             Expr::Call { span, .. } => *span,
+            Expr::New { span, .. } => *span,
             Expr::Member { span, .. } => *span,
             Expr::Index { span, .. } => *span,
             Expr::Conditional { span, .. } => *span,

package/crates/tish_build_utils/src/lib.rs

@@ -7,6 +7,14 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
+/// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
+///
+/// Used so we do not treat unrelated workspaces (e.g. a parent `zectre-platform` repo) as Tish
+/// when `CARGO_MANIFEST_DIR` or cwd points at another Rust workspace.
+fn is_tish_workspace_root(root: &Path) -> bool {
+    root.join("crates").join("tish_runtime").is_dir()
+}
+
 /// Find the Tish workspace root using multiple strategies.
 ///
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
@@ -18,7 +26,7 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         // For crates/tish_*, workspace root is parent.parent()
         if let Some(root) = path.parent().and_then(|p| p.parent()) {
             let root_buf = root.to_path_buf();
-            if root_buf.join("Cargo.toml").exists() {
+            if root_buf.join("Cargo.toml").exists() && is_tish_workspace_root(&root_buf) {
                 return Ok(root_buf);
             }
         }
@@ -47,7 +55,7 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
             let cargo_toml = current.join("Cargo.toml");
             if cargo_toml.exists() {
                 if let Ok(content) = std::fs::read_to_string(&cargo_toml) {
-                    if content.contains("[workspace]") {
+                    if content.contains("[workspace]") && is_tish_workspace_root(&current) {
                         return Ok(current);
                     }
                 }

package/crates/tish_builtins/src/construct.rs

@@ -0,0 +1,177 @@
+//! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
+//! Browser-exact behavior remains on `tish compile --target js`.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use tishlang_core::{ObjectMap, Value};
+
+const CONSTRUCT: &str = "__construct";
+
+/// Host `new`: `Object` with `__construct`, `Function` as plain call, else `Null`.
+pub fn construct(callee: &Value, args: &[Value]) -> Value {
+    match callee {
+        Value::Function(f) => f(args),
+        Value::Object(o) => {
+            let b = o.borrow();
+            if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
+                let c = Rc::clone(ctor);
+                drop(b);
+                return c(args);
+            }
+            Value::Null
+        }
+        _ => Value::Null,
+    }
+}
+
+fn param(initial: f64) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("value"), Value::Number(initial));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn connect_fn() -> Value {
+    Value::Function(Rc::new(|_| Value::Null))
+}
+
+/// Shared audio-node shape: connect, gain, optional filter fields.
+fn audio_node_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("gain"), param(0.0));
+    m.insert(Arc::from("frequency"), param(440.0));
+    m.insert(Arc::from("Q"), param(1.0));
+    m.insert(Arc::from("type"), Value::String("peaking".into()));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn analyser_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("fftSize"), Value::Number(2048.0));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn stereo_panner_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("pan"), param(0.0));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn audio_buffer_stub(len: usize) -> Value {
+    let n = len.max(1);
+    let data = Rc::new(RefCell::new(vec![Value::Number(0.0); n]));
+    let data2 = Rc::clone(&data);
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from("getChannelData"),
+        Value::Function(Rc::new(move |_args| Value::Array(Rc::clone(&data2)))),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn buffer_source_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("buffer"), Value::Null);
+    m.insert(Arc::from("loop"), Value::Bool(false));
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(
+        Arc::from("start"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    m.insert(
+        Arc::from("stop"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn oscillator_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("frequency"), param(440.0));
+    m.insert(Arc::from("type"), Value::String("sine".into()));
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(
+        Arc::from("start"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    m.insert(
+        Arc::from("stop"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn audio_context_instance() -> Value {
+    let mut ctx = ObjectMap::default();
+    ctx.insert(Arc::from("sampleRate"), Value::Number(48_000.0));
+    ctx.insert(Arc::from("destination"), audio_node_stub());
+
+    ctx.insert(
+        Arc::from("createGain"),
+        Value::Function(Rc::new(|_| audio_node_stub())),
+    );
+    ctx.insert(
+        Arc::from("createBiquadFilter"),
+        Value::Function(Rc::new(|_| audio_node_stub())),
+    );
+    ctx.insert(
+        Arc::from("createStereoPanner"),
+        Value::Function(Rc::new(|_| stereo_panner_stub())),
+    );
+    ctx.insert(
+        Arc::from("createAnalyser"),
+        Value::Function(Rc::new(|_| analyser_stub())),
+    );
+    ctx.insert(
+        Arc::from("createBuffer"),
+        Value::Function(Rc::new(|args: &[Value]| {
+            let len = args
+                .get(1)
+                .and_then(Value::as_number)
+                .unwrap_or(0.0)
+                .clamp(0.0, 1_000_000_000.0) as usize;
+            audio_buffer_stub(len)
+        })),
+    );
+    ctx.insert(
+        Arc::from("createBufferSource"),
+        Value::Function(Rc::new(|_| buffer_source_stub())),
+    );
+    ctx.insert(
+        Arc::from("createOscillator"),
+        Value::Function(Rc::new(|_| oscillator_stub())),
+    );
+    ctx.insert(
+        Arc::from("decodeAudioData"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+
+    Value::Object(Rc::new(RefCell::new(ctx)))
+}
+
+/// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
+pub fn uint8_array_constructor_value() -> Value {
+    let ctor = Rc::new(|args: &[Value]| {
+        let len = args
+            .first()
+            .and_then(Value::as_number)
+            .unwrap_or(0.0)
+            .clamp(0.0, 1_000_000_000.0) as usize;
+        Value::Array(Rc::new(RefCell::new(vec![Value::Number(0.0); len])))
+    });
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+/// Global `AudioContext` for native/VM: stub graph (no real audio).
+pub fn audio_context_constructor_value() -> Value {
+    let ctor = Rc::new(|_args: &[Value]| audio_context_instance());
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
+    Value::Object(Rc::new(RefCell::new(m)))
+}

package/crates/tish_builtins/src/globals.rs

@@ -4,10 +4,9 @@
 //! independent of tishlang_runtime.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::{percent_decode, percent_encode, Value};
+use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
 
 /// Boolean(value) - coerce to bool
 pub fn boolean(args: &[Value]) -> Value {
@@ -174,8 +173,7 @@ pub fn parse_float(args: &[Value]) -> Value {
 pub fn object_from_entries(args: &[Value]) -> Value {
     if let Some(Value::Array(entries)) = args.first() {
         let entries_borrow = entries.borrow();
-        let mut obj: HashMap<Arc<str>, Value> =
-            HashMap::with_capacity(entries_borrow.len());
+        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
 
         for entry in entries_borrow.iter() {
             if let Value::Array(pair) = entry {
@@ -192,6 +190,6 @@ pub fn object_from_entries(args: &[Value]) -> Value {
 
         Value::Object(Rc::new(RefCell::new(obj)))
     } else {
-        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
     }
 }

package/crates/tish_builtins/src/helpers.rs

@@ -1,10 +1,9 @@
 //! Common helper functions used across builtin implementations.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Normalize an array index, handling negative indices.
 /// Returns a valid index within bounds or the default value.
@@ -24,7 +23,7 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 
 /// Create an error object with a single "error" field.
 pub fn make_error_value(e: impl std::fmt::Display) -> Value {
-    let mut obj = HashMap::with_capacity(1);
+    let mut obj = ObjectMap::with_capacity(1);
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
     Value::Object(Rc::new(RefCell::new(obj)))
 }

package/crates/tish_builtins/src/lib.rs

@@ -10,5 +10,6 @@ pub mod object;
 pub mod math;
 pub mod helpers;
 pub mod globals;
+pub mod construct;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/object.rs

@@ -4,19 +4,18 @@
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
-    Value::Object(Rc::new(RefCell::new(HashMap::new())))
+    Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
 }
 
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
-    Value::Object(Rc::new(RefCell::new(HashMap::with_capacity(capacity))))
+    Value::Object(Rc::new(RefCell::new(ObjectMap::with_capacity(capacity))))
 }
 
 /// Get the keys of an object.

package/crates/tish_bytecode/src/compiler.rs

@@ -5,7 +5,8 @@ use std::sync::Arc;
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, DestructElement, DestructPattern, Expr,
-    JsxAttrValue, JsxChild, JsxProp, Literal, MemberProp, ObjectProp, Program, Span, Statement,
+    FunParam, JsxAttrValue, JsxChild, JsxProp, Literal, MemberProp, ObjectProp, Program, Span,
+    Statement,
 };
 
 use crate::chunk::{Chunk, Constant};
@@ -137,8 +138,14 @@ impl<'a> Compiler<'a> {
             if params.len() != 2 {
                 return None;
             }
-            let param_a = params[0].name.as_ref();
-            let param_b = params[1].name.as_ref();
+            let (param_a, param_b) = match (&params[0], &params[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (a.name.as_ref(), b.name.as_ref())
+                }
+                _ => return None,
+            };
             let body_expr = match body {
                 ArrowBody::Expr(e) => e.as_ref(),
                 ArrowBody::Block(stmt) => {
@@ -184,8 +191,14 @@ impl<'a> Compiler<'a> {
             if params.len() != 2 {
                 return None;
             }
-            let param_a = params[0].name.as_ref();
-            let param_b = params[1].name.as_ref();
+            let (param_a, param_b) = match (&params[0], &params[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (a.name.as_ref(), b.name.as_ref())
+                }
+                _ => return None,
+            };
             let body_expr = match body {
                 ArrowBody::Expr(e) => e.as_ref(),
                 ArrowBody::Block(stmt) => {
@@ -228,7 +241,10 @@ impl<'a> Compiler<'a> {
         if params.len() != 1 {
             return None;
         }
-        let param_name = params[0].name.as_ref();
+        let param_name = match &params[0] {
+            FunParam::Simple(tp) if tp.default.is_none() => tp.name.as_ref(),
+            _ => return None,
+        };
         let expr_ref: &Expr = match body {
             ArrowBody::Expr(e) => e.as_ref(),
             ArrowBody::Block(stmt) => {
@@ -277,7 +293,10 @@ impl<'a> Compiler<'a> {
         if params.len() != 1 {
             return None;
         }
-        let param_name = params[0].name.as_ref();
+        let param_name = match &params[0] {
+            FunParam::Simple(tp) if tp.default.is_none() => tp.name.as_ref(),
+            _ => return None,
+        };
         let expr_ref: &Expr = match body {
             ArrowBody::Expr(e) => e.as_ref(),
             ArrowBody::Block(stmt) => {
@@ -550,9 +569,22 @@ impl<'a> Compiler<'a> {
                 async_: _,
                 ..
             } => {
+                for p in params {
+                    if matches!(p, FunParam::Destructure { .. }) {
+                        return Err(CompileError {
+                            message: "Destructuring parameters are not supported in bytecode"
+                                .to_string(),
+                        });
+                    }
+                }
                 let mut inner = Chunk::new();
-                let mut param_names: Vec<Arc<str>> =
-                    params.iter().map(|p| Arc::clone(&p.name)).collect();
+                let mut param_names: Vec<Arc<str>> = params
+                    .iter()
+                    .map(|p| match p {
+                        FunParam::Simple(tp) => Arc::clone(&tp.name),
+                        _ => unreachable!(),
+                    })
+                    .collect();
                 if let Some(rp) = rest_param {
                     param_names.push(rp.name.clone());
                     inner.rest_param_index = (param_names.len() as u16).saturating_sub(1);
@@ -1061,9 +1093,22 @@ impl<'a> Compiler<'a> {
                 self.emit_u16(Opcode::Call, 1);
             }
             Expr::ArrowFunction { params, body, .. } => {
+                for p in params {
+                    if matches!(p, FunParam::Destructure { .. }) {
+                        return Err(CompileError {
+                            message: "Destructuring parameters are not supported in bytecode"
+                                .to_string(),
+                        });
+                    }
+                }
                 let mut inner = Chunk::new();
-                let param_names: Vec<Arc<str>> =
-                    params.iter().map(|p| Arc::clone(&p.name)).collect();
+                let param_names: Vec<Arc<str>> = params
+                    .iter()
+                    .map(|p| match p {
+                        FunParam::Simple(tp) => Arc::clone(&tp.name),
+                        _ => unreachable!(),
+                    })
+                    .collect();
                 for p in &param_names {
                     inner.add_name(Arc::clone(p));
                 }
@@ -1205,6 +1250,35 @@ impl<'a> Compiler<'a> {
                     message: "Logical assignment (&&=, ||=, ??=) not yet supported in bytecode".to_string(),
                 });
             }
+            Expr::New { callee, args, .. } => {
+                let has_spread = args.iter().any(|a| matches!(a, CallArg::Spread(_)));
+                if has_spread {
+                    self.emit_u16(Opcode::NewArray, 0);
+                    for arg in args {
+                        match arg {
+                            CallArg::Expr(e) => {
+                                self.compile_expr(e)?;
+                                self.emit_u16(Opcode::NewArray, 1);
+                                self.emit(Opcode::ConcatArray);
+                            }
+                            CallArg::Spread(expr) => {
+                                self.compile_expr(expr)?;
+                                self.emit(Opcode::ConcatArray);
+                            }
+                        }
+                    }
+                    self.compile_expr(callee)?;
+                    self.emit(Opcode::ConstructSpread);
+                } else {
+                    self.compile_expr(callee)?;
+                    for arg in args {
+                        if let CallArg::Expr(e) = arg {
+                            self.compile_expr(e)?;
+                        }
+                    }
+                    self.emit_u16(Opcode::Construct, args.len() as u16);
+                }
+            }
         }
         Ok(())
     }