diff --git a/crates/dash_compiler/src/builder.rs b/crates/dash_compiler/src/builder.rs
index a428778e..aa393fd5 100755
--- a/crates/dash_compiler/src/builder.rs
+++ b/crates/dash_compiler/src/builder.rs
@@ -7,7 +7,7 @@ use dash_middle::compiler::instruction::Instruction;
 use crate::jump_container::JumpContainer;
 use crate::{jump_container, FunctionCompiler};
 
-#[derive(PartialOrd, Ord, Hash, Eq, PartialEq, Debug, Clone)]
+#[derive(PartialOrd, Ord, Hash, Eq, PartialEq, Debug, Clone, Copy)]
 pub enum Label {
     IfEnd,
     /// A branch of an if statement
@@ -33,6 +33,9 @@ pub enum Label {
         switch_id: usize,
     },
     Catch,
+    Finally {
+        finally_id: usize,
+    },
     TryEnd,
     InitParamWithDefaultValue,
     FinishParamDefaultValueInit,
diff --git a/crates/dash_compiler/src/instruction.rs b/crates/dash_compiler/src/instruction.rs
index b94a8a55..0b884a0b 100755
--- a/crates/dash_compiler/src/instruction.rs
+++ b/crates/dash_compiler/src/instruction.rs
@@ -87,10 +87,25 @@ impl<'cx, 'interner> InstructionBuilder<'cx, 'interner> {
         Ok(())
     }
 
-    pub fn build_try_block(&mut self) {
+    fn write_bool(&mut self, b: bool) {
+        self.write(b.into());
+    }
+
+    pub fn build_try_block(&mut self, has_catch: bool, finally_id: Option<usize>) {
         self.write_instr(Instruction::Try);
-        self.write_all(&[0, 0]);
+        self.write_bool(has_catch);
+        if has_catch {
+            self.write_all(&[0, 0]);
+        }
+        // NOTE: even though we won't *really* perform a jump (we skip over the following `jump` instruction emitted by this call in the vm dispatcher)
+        // we use the local jump resolving mechanism for updating the catch offset
         self.add_local_jump(Label::Catch);
+        self.write_bool(finally_id.is_some());
+        if let Some(finally_id) = finally_id {
+            self.write_all(&[0, 0]);
+            self.current_function_mut()
+                .add_global_jump(Label::Finally { finally_id });
+        }
     }
 
     pub fn build_local_load(&mut self, index: u16, is_extern: bool) {
@@ -99,7 +114,8 @@ impl<'cx, 'interner> InstructionBuilder<'cx, 'interner> {
 
     pub fn build_global_load(&mut self, ident: Symbol) -> Result<(), LimitExceededError> {
         let id = self.current_function_mut().cp.add(Constant::Identifier(ident))?;
-        self.write_wide_instr(Instruction::LdGlobal, Instruction::LdGlobalW, id);
+        self.write_instr(Instruction::LdGlobal);
+        self.writew(id);
         Ok(())
     }
 
diff --git a/crates/dash_compiler/src/lib.rs b/crates/dash_compiler/src/lib.rs
index 126d5f60..fa225ba2 100644
--- a/crates/dash_compiler/src/lib.rs
+++ b/crates/dash_compiler/src/lib.rs
@@ -23,6 +23,7 @@ use dash_middle::parser::statement::{
     VariableDeclaration, VariableDeclarationKind, VariableDeclarationName, VariableDeclarations, WhileLoop,
 };
 use dash_middle::sourcemap::Span;
+use dash_middle::util::Counter;
 use dash_middle::visitor::Visitor;
 use dash_optimizer::consteval::ConstFunctionEvalCtx;
 use dash_optimizer::type_infer::TypeInferCtx;
@@ -64,8 +65,11 @@ struct FunctionLocalState {
     ///
     /// Bytecode can refer to constants using the [Instruction::Constant] instruction, followed by a u8 index.
     cp: ConstantPool,
-    /// Current try catch depth
-    try_catch_depth: u16,
+    /// Current `try` depth (note that this does NOT include `catch`es)
+    try_depth: u16,
+    /// A stack of try-catch-finally blocks and their optional `finally` label that can be jumped to
+    finally_labels: Vec<Option<Label>>,
+    finally_counter: Counter<usize>,
     /// The type of function that this FunctionCompiler compiles
     ty: FunctionKind,
     /// Container, used for storing global labels that can be jumped to
@@ -89,7 +93,9 @@ impl FunctionLocalState {
         Self {
             buf: Vec::new(),
             cp: ConstantPool::new(),
-            try_catch_depth: 0,
+            try_depth: 0,
+            finally_labels: Vec::new(),
+            finally_counter: Counter::new(),
             ty,
             jc: JumpContainer::new(),
             breakables: Vec::new(),
@@ -120,6 +126,7 @@ impl FunctionLocalState {
         self.switch_counter += 1;
         switch_id
     }
+
     fn exit_loop(&mut self) {
         let item = self.breakables.pop();
         match item {
@@ -151,6 +158,17 @@ impl FunctionLocalState {
             FunctionKind::Generator | FunctionKind::Arrow => false,
         }
     }
+
+    pub fn is_generator_or_async(&self) -> bool {
+        matches!(
+            self.ty,
+            FunctionKind::Function(Asyncness::Yes) | FunctionKind::Generator
+        )
+    }
+
+    fn enclosing_finally(&self) -> Option<Label> {
+        self.finally_labels.iter().copied().rev().find_map(|lbl| lbl)
+    }
 }
 
 #[derive(Debug)]
@@ -1459,9 +1477,18 @@ impl<'interner> Visitor<Result<(), Error>> for FunctionCompiler<'interner> {
     }
 
     fn visit_return_statement(&mut self, _span: Span, ReturnStatement(stmt): ReturnStatement) -> Result<(), Error> {
-        let tc_depth = self.current_function().try_catch_depth;
-        self.accept_expr(stmt)?;
-        InstructionBuilder::new(self).build_ret(tc_depth);
+        let mut ib = InstructionBuilder::new(self);
+        let finally = ib.current_function().enclosing_finally();
+
+        let tc_depth = ib.current_function().try_depth;
+        ib.accept_expr(stmt)?;
+        if let Some(finally) = finally {
+            ib.write_instr(Instruction::DelayedReturn);
+            ib.build_jmp(finally, false);
+        } else {
+            ib.build_ret(tc_depth);
+        }
+
         Ok(())
     }
 
@@ -1807,45 +1834,75 @@ impl<'interner> Visitor<Result<(), Error>> for FunctionCompiler<'interner> {
         Ok(())
     }
 
-    fn visit_try_catch(&mut self, span: Span, TryCatch { try_, catch, .. }: TryCatch) -> Result<(), Error> {
+    fn visit_try_catch(&mut self, span: Span, TryCatch { try_, catch, finally }: TryCatch) -> Result<(), Error> {
         let mut ib = InstructionBuilder::new(self);
 
-        ib.build_try_block();
+        let finally = finally.map(|f| (ib.current_function_mut().finally_counter.inc(), f));
 
-        ib.current_function_mut().try_catch_depth += 1;
+        ib.build_try_block(catch.is_some(), finally.as_ref().map(|&(id, _)| id));
+
+        ib.current_function_mut().try_depth += 1;
+        ib.current_function_mut()
+            .finally_labels
+            .push(finally.as_ref().map(|&(finally_id, _)| Label::Finally { finally_id }));
         ib.current_scope_mut().enter();
         let res = ib.accept(*try_); // TODO: some API for making this nicer
         ib.current_scope_mut().exit();
-        ib.current_function_mut().try_catch_depth -= 1;
+        ib.current_function_mut().try_depth -= 1;
         res?;
 
         ib.build_jmp(Label::TryEnd, true);
 
-        ib.add_local_label(Label::Catch);
-
         ib.current_scope_mut().enter();
 
-        if let Some(ident) = catch.ident {
-            let id = ib
-                .current_scope_mut()
-                .add_local(ident, VariableDeclarationKind::Var, None)
-                .map_err(|_| Error::LocalLimitExceeded(span))?;
+        if catch.is_none() && finally.is_none() {
+            // FIXME: make it a real error
+            unimplementedc!(span, "try block has no catch or finally");
+        }
+
+        if let Some(catch) = catch {
+            ib.add_local_label(Label::Catch);
+
+            if let Some(ident) = catch.ident {
+                let id = ib
+                    .current_scope_mut()
+                    .add_local(ident, VariableDeclarationKind::Var, None)
+                    .map_err(|_| Error::LocalLimitExceeded(span))?;
 
-            if id == u16::MAX {
-                // Max u16 value is reserved for "no binding"
-                return Err(Error::LocalLimitExceeded(span));
+                if id == u16::MAX {
+                    // Max u16 value is reserved for "no binding"
+                    return Err(Error::LocalLimitExceeded(span));
+                }
+
+                ib.writew(id);
+            } else {
+                ib.writew(u16::MAX);
             }
 
-            ib.writew(id);
-        } else {
-            ib.writew(u16::MAX);
+            ib.accept(*catch.body)?;
         }
-
-        ib.accept(*catch.body)?;
         ib.current_scope_mut().exit();
+        ib.current_function_mut().finally_labels.pop();
+
+        if let Some((finally_id, finally)) = finally {
+            if ib.current_function().is_generator_or_async() {
+                // TODO: is this also already an issue without finally?
+                unimplementedc!(span, "try-finally in generator function");
+            }
+
+            ib.current_function_mut()
+                .add_global_label(Label::Finally { finally_id });
+            ib.add_local_label(Label::TryEnd);
+            ib.build_try_end();
 
-        ib.add_local_label(Label::TryEnd);
-        ib.build_try_end();
+            ib.accept(*finally)?;
+
+            ib.write_instr(Instruction::FinallyEnd);
+            ib.writew(ib.current_function().try_depth);
+        } else {
+            ib.add_local_label(Label::TryEnd);
+            ib.build_try_end();
+        }
 
         Ok(())
     }
@@ -2016,6 +2073,11 @@ impl<'interner> Visitor<Result<(), Error>> for FunctionCompiler<'interner> {
 
     fn visit_break(&mut self, span: Span) -> Result<(), Error> {
         let mut ib = InstructionBuilder::new(self);
+
+        if ib.current_function().enclosing_finally().is_some() {
+            unimplementedc!(span, "`break` in a try-finally block");
+        }
+
         let breakable = *ib
             .current_function_mut()
             .breakables
@@ -2035,6 +2097,11 @@ impl<'interner> Visitor<Result<(), Error>> for FunctionCompiler<'interner> {
 
     fn visit_continue(&mut self, span: Span) -> Result<(), Error> {
         let mut ib = InstructionBuilder::new(self);
+
+        if ib.current_function().enclosing_finally().is_some() {
+            unimplementedc!(span, "`continue` in a try-finally block");
+        }
+
         let breakable = *ib
             .current_function_mut()
             .breakables
diff --git a/crates/dash_compiler/src/transformations.rs b/crates/dash_compiler/src/transformations.rs
index 59846379..a26035a9 100644
--- a/crates/dash_compiler/src/transformations.rs
+++ b/crates/dash_compiler/src/transformations.rs
@@ -173,7 +173,9 @@ pub fn hoist_declarations(ast: &mut Vec<Statement>) {
             }
             StatementKind::Try(tc_stmt) => {
                 hoist_function_declaration(prepend_function_assigns, &mut tc_stmt.try_);
-                hoist_function_declaration(prepend_function_assigns, &mut tc_stmt.catch.body);
+                if let Some(catch) = &mut tc_stmt.catch {
+                    hoist_function_declaration(prepend_function_assigns, &mut catch.body);
+                }
                 if let Some(finally_stmt) = &mut tc_stmt.finally {
                     hoist_function_declaration(prepend_function_assigns, finally_stmt);
                 }
diff --git a/crates/dash_decompiler/src/decompiler.rs b/crates/dash_decompiler/src/decompiler.rs
index a44b201f..5ec114e2 100644
--- a/crates/dash_decompiler/src/decompiler.rs
+++ b/crates/dash_decompiler/src/decompiler.rs
@@ -190,13 +190,9 @@ impl<'interner, 'buf> FunctionDecompiler<'interner, 'buf> {
                 }
                 Instruction::Arguments => self.handle_opless_instr("arguments"),
                 Instruction::LdGlobal => {
-                    let b = self.read()?;
+                    let b = self.read_i16()?;
                     self.handle_op_instr("ldglobal", &[&self.display(&self.constants[b as usize])]);
                 }
-                Instruction::LdGlobalW => {
-                    let b = self.read_u16()?;
-                    self.handle_op_instr("ldglobalw", &[&self.display(&self.constants[b as usize])]);
-                }
                 Instruction::StoreLocal => self.handle_inc_op_instr2("storelocal")?,
                 Instruction::StoreLocalW => self.handle_inc_op_instr2("storelocalw")?,
                 Instruction::Call => {
@@ -218,6 +214,7 @@ impl<'interner, 'buf> FunctionDecompiler<'interner, 'buf> {
                     self.read_u16()?; // intentionally ignored
                     self.handle_opless_instr("ret")
                 }
+                Instruction::DelayedReturn => self.handle_opless_instr("delayedret"),
                 Instruction::Pos => self.handle_opless_instr("pos"),
                 Instruction::Neg => self.handle_opless_instr("neg"),
                 Instruction::TypeOfGlobalIdent => {
@@ -286,6 +283,7 @@ impl<'interner, 'buf> FunctionDecompiler<'interner, 'buf> {
                 Instruction::StrictNe => self.handle_opless_instr("strictne"),
                 Instruction::Try => self.handle_incw_op_instr("try")?, // TODO: show @offset like in JMP
                 Instruction::TryEnd => self.handle_opless_instr("tryend"),
+                Instruction::FinallyEnd => self.handle_opless_instr("finallyend"),
                 Instruction::Throw => self.handle_opless_instr("throw"),
                 Instruction::Yield => self.handle_opless_instr("yield"),
                 Instruction::BitOr => self.handle_opless_instr("bitor"),
diff --git a/crates/dash_middle/src/compiler/instruction.rs b/crates/dash_middle/src/compiler/instruction.rs
index f61baba5..74a801d9 100644
--- a/crates/dash_middle/src/compiler/instruction.rs
+++ b/crates/dash_middle/src/compiler/instruction.rs
@@ -22,7 +22,6 @@ pub enum Instruction {
     LdLocal,
     LdLocalW,
     LdGlobal,
-    LdGlobalW,
     Constant,
     ConstantW,
     Pos,
@@ -59,6 +58,7 @@ pub enum Instruction {
     StrictNe,
     Try,
     TryEnd,
+    FinallyEnd,
     Throw,
     Yield,
     JmpFalseNP,
@@ -96,6 +96,7 @@ pub enum Instruction {
     ObjDestruct,
     ArrayDestruct,
     AssignProperties,
+    DelayedReturn,
     // Nop exists solely for the sake of benchmarking the raw throughput of the VM dispatch loop
     Nop,
 }
diff --git a/crates/dash_middle/src/interner.rs b/crates/dash_middle/src/interner.rs
index 8461a623..377cb271 100644
--- a/crates/dash_middle/src/interner.rs
+++ b/crates/dash_middle/src/interner.rs
@@ -138,6 +138,7 @@ pub mod sym {
                 call,
                 create,
                 keys,
+                getOwnPropertyNames,
                 getOwnPropertyDescriptor,
                 getOwnPropertyDescriptors,
                 defineProperty,
diff --git a/crates/dash_middle/src/parser/statement.rs b/crates/dash_middle/src/parser/statement.rs
index bda086bf..4c834b85 100644
--- a/crates/dash_middle/src/parser/statement.rs
+++ b/crates/dash_middle/src/parser/statement.rs
@@ -205,14 +205,18 @@ pub struct TryCatch {
     pub try_: Box<Statement>,
     /// Catch statement
     // TODO: make this optional. a try can exist without catch (try finally)
-    pub catch: Catch,
+    pub catch: Option<Catch>,
     /// Optional finally block
     pub finally: Option<Box<Statement>>,
 }
 
 impl fmt::Display for TryCatch {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "try {{ {} }} {}", self.try_, self.catch)?;
+        write!(f, "try {{ {} }} ", self.try_)?;
+
+        if let Some(catch) = &self.catch {
+            write!(f, "{catch}")?;
+        }
 
         if let Some(finally) = &self.finally {
             write!(f, " finally {{ {finally} }}")?;
@@ -224,7 +228,7 @@ impl fmt::Display for TryCatch {
 
 impl TryCatch {
     /// Creates a new try catch block
-    pub fn new(try_: Statement, catch: Catch, finally: Option<Statement>) -> Self {
+    pub fn new(try_: Statement, catch: Option<Catch>, finally: Option<Statement>) -> Self {
         Self {
             try_: Box::new(try_),
             catch,
diff --git a/crates/dash_middle/src/util.rs b/crates/dash_middle/src/util.rs
index 0a4074a6..2ee046bf 100644
--- a/crates/dash_middle/src/util.rs
+++ b/crates/dash_middle/src/util.rs
@@ -275,7 +275,7 @@ where
         Self(start.into(), PhantomData)
     }
 
-    pub fn advance(&mut self) -> T {
+    pub fn inc(&mut self) -> T {
         let old = self.0;
         self.0 += 1;
         T::from(old)
diff --git a/crates/dash_node_impl/src/lib.rs b/crates/dash_node_impl/src/lib.rs
index 034db8e0..cc2c1692 100644
--- a/crates/dash_node_impl/src/lib.rs
+++ b/crates/dash_node_impl/src/lib.rs
@@ -203,7 +203,11 @@ impl Object for RequireFunction {
         let is_path = matches!(arg.chars().next(), Some('.' | '/' | '~'));
         let result = if is_path {
             if !arg.ends_with(".js") && !arg.ends_with(".json") {
-                arg += ".js";
+                if std::fs::metadata(self.current_dir.join(&arg)).is_ok_and(|md| md.is_dir()) {
+                    arg += "/index.js";
+                } else {
+                    arg += ".js";
+                }
             }
 
             let canonicalized_path = match self.current_dir.join(&arg).canonicalize() {
diff --git a/crates/dash_node_impl/src/native.rs b/crates/dash_node_impl/src/native.rs
index b00cb3e8..492b6bc7 100644
--- a/crates/dash_node_impl/src/native.rs
+++ b/crates/dash_node_impl/src/native.rs
@@ -1,4 +1,6 @@
 use dash_vm::localscope::LocalScope;
+use dash_vm::value::function::native::register_native_fn;
+use dash_vm::value::object::{NamedObject, Object, PropertyValue};
 use dash_vm::value::string::JsString;
 use dash_vm::value::Value;
 
@@ -45,6 +47,31 @@ pub fn load_native_module(sc: &mut LocalScope<'_>, arg: JsString) -> Result<Opti
         #[cfg(feature = "path")]
         state.sym.path => (state_mut(sc).path_cache, crate::path::init_module),
         #[cfg(feature = "events")]
-        state.sym.events => (state_mut(sc).path_cache, crate::events::init_module)
+        state.sym.events => (state_mut(sc).path_cache, crate::events::init_module),
+        #[]
+        state.sym.stream => (state_mut(sc).stream_cache, init_stream),
+        #[]
+        state.sym.http => (state_mut(sc).path_cache, init_dummy_empty_module),
+        #[]
+        state.sym.https => (state_mut(sc).path_cache, init_dummy_empty_module),
+        #[]
+        state.sym.url => (state_mut(sc).path_cache, init_dummy_empty_module),
+        #[]
+        state.sym.zlib => (state_mut(sc).path_cache, init_dummy_empty_module),
+        #[]
+        state.sym.punycode => (state_mut(sc).path_cache, init_dummy_empty_module)
     }
 }
+
+fn init_dummy_empty_module(sc: &mut LocalScope<'_>) -> Result<Value, Value> {
+    let exports = NamedObject::new(sc);
+    Ok(Value::Object(sc.register(exports)))
+}
+
+fn init_stream(sc: &mut LocalScope<'_>) -> Result<Value, Value> {
+    let exports = NamedObject::new(sc);
+    let readable = sc.intern("Readable");
+    let readable_fn = register_native_fn(sc, readable, |_sc| Ok(Value::undefined()));
+    exports.set_property(sc, readable.into(), PropertyValue::static_default(readable_fn.into()))?;
+    Ok(Value::Object(sc.register(exports)))
+}
diff --git a/crates/dash_node_impl/src/package.rs b/crates/dash_node_impl/src/package.rs
index 2107f1f7..81b52d5f 100644
--- a/crates/dash_node_impl/src/package.rs
+++ b/crates/dash_node_impl/src/package.rs
@@ -4,11 +4,16 @@ use std::path::PathBuf;
 use dash_proc_macro::Trace;
 use serde::Deserialize;
 
+fn default_main() -> PathBuf {
+    "index.js".into()
+}
+
 #[derive(Deserialize, Debug, Trace)]
 pub struct Package {
     pub name: String,
     pub version: String,
     pub description: String,
+    #[serde(default = "default_main")]
     pub main: PathBuf,
     #[serde(default)]
     pub dependencies: HashMap<String, String>,
diff --git a/crates/dash_node_impl/src/state.rs b/crates/dash_node_impl/src/state.rs
index 696829e4..61188e31 100644
--- a/crates/dash_node_impl/src/state.rs
+++ b/crates/dash_node_impl/src/state.rs
@@ -6,7 +6,7 @@ use dash_rt::typemap::Key;
 use dash_vm::value::Value;
 use dash_vm::Vm;
 
-define_symbol_set!(#[derive(Trace)] NodeSymbols => [fs, fetch, path, parse, dir, events, EventEmitter, on, emit]);
+define_symbol_set!(#[derive(Trace)] NodeSymbols => [fs, fetch, path, parse, dir, events, EventEmitter, on, emit, stream, http, https, url, zlib, punycode]);
 
 #[derive(Trace)]
 pub struct State {
@@ -14,6 +14,7 @@ pub struct State {
     pub fs_cache: OnceCell<Value>,
     pub fetch_cache: OnceCell<Value>,
     pub path_cache: OnceCell<Value>,
+    pub stream_cache: OnceCell<Value>,
 }
 
 impl State {
@@ -23,6 +24,7 @@ impl State {
             fs_cache: OnceCell::new(),
             fetch_cache: OnceCell::new(),
             path_cache: OnceCell::new(),
+            stream_cache: OnceCell::new(),
         }
     }
 }
diff --git a/crates/dash_optimizer/src/consteval.rs b/crates/dash_optimizer/src/consteval.rs
index 5cc99ff5..c696cfdc 100644
--- a/crates/dash_optimizer/src/consteval.rs
+++ b/crates/dash_optimizer/src/consteval.rs
@@ -109,7 +109,9 @@ impl<'b, 'interner> ConstFunctionEvalCtx<'b, 'interner> {
 
     pub fn visit_try_statement(&mut self, TryCatch { try_, catch, finally }: &mut TryCatch, func_id: FuncId) {
         self.visit_statement(try_, func_id);
-        self.visit_statement(&mut catch.body, func_id);
+        if let Some(catch) = catch {
+            self.visit_statement(&mut catch.body, func_id);
+        }
         self.visit_maybe_statement(finally.as_deref_mut(), func_id);
     }
 
diff --git a/crates/dash_optimizer/src/type_infer.rs b/crates/dash_optimizer/src/type_infer.rs
index db09f3f0..fc12bcd4 100644
--- a/crates/dash_optimizer/src/type_infer.rs
+++ b/crates/dash_optimizer/src/type_infer.rs
@@ -114,7 +114,9 @@ impl TypeInferCtx {
 
     pub fn visit_try_statement(&mut self, TryCatch { try_, catch, finally }: &TryCatch, func_id: FuncId) {
         self.visit_statement(try_, func_id);
-        self.visit_statement(&catch.body, func_id);
+        if let Some(catch) = catch {
+            self.visit_statement(&catch.body, func_id);
+        }
         self.visit_maybe_statement(finally.as_deref(), func_id);
     }
 
diff --git a/crates/dash_parser/src/expr.rs b/crates/dash_parser/src/expr.rs
index 8f73e69f..0fba1836 100644
--- a/crates/dash_parser/src/expr.rs
+++ b/crates/dash_parser/src/expr.rs
@@ -532,7 +532,7 @@ impl<'a, 'interner> Parser<'a, 'interner> {
                                 let parameters = self.parse_parameter_list()?;
                                 self.expect_token_type_and_skip(&[TokenType::LeftBrace], true);
                                 let body = self.parse_block()?;
-                                let id = self.function_counter.advance();
+                                let id = self.function_counter.inc();
                                 items.push((
                                     key,
                                     Expr {
@@ -598,7 +598,7 @@ impl<'a, 'interner> Parser<'a, 'interner> {
                             let BlockStatement(stmts) = self.parse_block()?;
 
                             // Desugar to function
-                            let func_id = self.function_counter.advance();
+                            let func_id = self.function_counter.inc();
                             let fun = FunctionDeclaration::new(
                                 None,
                                 func_id,
@@ -810,7 +810,7 @@ impl<'a, 'interner> Parser<'a, 'interner> {
 
         self.new_level_stack.pop_level().unwrap();
 
-        let func_id = self.function_counter.advance();
+        let func_id = self.function_counter.inc();
         Some((
             FunctionDeclaration::new(name, func_id, arguments, statements, ty, ty_seg, None),
             self.previous()?.span,
@@ -865,7 +865,7 @@ impl<'a, 'interner> Parser<'a, 'interner> {
             }
         };
 
-        let func_id = self.function_counter.advance();
+        let func_id = self.function_counter.inc();
         Some(Expr {
             span: pre_span.to(body.span),
             kind: ExprKind::function(FunctionDeclaration::new(
diff --git a/crates/dash_parser/src/stmt.rs b/crates/dash_parser/src/stmt.rs
index b3472763..e890f0ad 100644
--- a/crates/dash_parser/src/stmt.rs
+++ b/crates/dash_parser/src/stmt.rs
@@ -137,7 +137,7 @@ impl<'a, 'interner> Parser<'a, 'interner> {
 
                 let body = self.parse_statement()?;
 
-                let func_id = self.function_counter.advance();
+                let func_id = self.function_counter.inc();
                 let func = FunctionDeclaration::new(
                     match key {
                         ClassMemberKey::Named(name) => Some(name),
@@ -271,21 +271,27 @@ impl<'a, 'interner> Parser<'a, 'interner> {
     fn parse_try(&mut self) -> Option<TryCatch> {
         let try_ = self.parse_statement()?;
 
-        self.expect_token_type_and_skip(&[TokenType::Catch], true);
+        let catch = if self.expect_token_type_and_skip(&[TokenType::Catch], false) {
+            let capture_ident = if self.expect_token_type_and_skip(&[TokenType::LeftParen], false) {
+                let ident = self.expect_identifier(true)?;
+                self.expect_token_type_and_skip(&[TokenType::RightParen], true);
+                Some(ident)
+            } else {
+                None
+            };
 
-        let capture_ident = if self.expect_token_type_and_skip(&[TokenType::LeftParen], false) {
-            let ident = self.expect_identifier(true)?;
-            self.expect_token_type_and_skip(&[TokenType::RightParen], true);
-            Some(ident)
+            Some(Catch::new(self.parse_statement()?, capture_ident))
         } else {
             None
         };
 
-        let catch = self.parse_statement()?;
-
-        // TODO: finally
+        let finally = if self.expect_token_type_and_skip(&[TokenType::Finally], false) {
+            Some(self.parse_statement()?)
+        } else {
+            None
+        };
 
-        Some(TryCatch::new(try_, Catch::new(catch, capture_ident), None))
+        Some(TryCatch::new(try_, catch, finally))
     }
 
     fn parse_return(&mut self) -> Option<ReturnStatement> {
diff --git a/crates/dash_vm/src/dispatch.rs b/crates/dash_vm/src/dispatch.rs
index d10fb703..40dc088f 100755
--- a/crates/dash_vm/src/dispatch.rs
+++ b/crates/dash_vm/src/dispatch.rs
@@ -532,6 +532,24 @@ mod extract {
             })
         }
     }
+
+    impl<E, T: ExtractBack<Exception = E>> ExtractBack for Option<T> {
+        type Exception = E;
+        fn extract(cx: &mut DispatchContext<'_, '_>) -> Result<Self, Self::Exception> {
+            match cx.fetch_and_inc_ip() {
+                0 => Ok(None),
+                1 => Ok(Some(T::extract(cx)?)),
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    impl ExtractBack for u16 {
+        type Exception = Infallible;
+        fn extract(cx: &mut DispatchContext<'_, '_>) -> Result<Self, Self::Exception> {
+            Ok(cx.fetchw_and_inc_ip())
+        }
+    }
 }
 
 mod handlers {
@@ -539,7 +557,7 @@ mod handlers {
     use dash_middle::compiler::{FunctionCallMetadata, StaticImportKind};
     use dash_middle::interner::sym;
     use dash_middle::iterator_with::{InfallibleIteratorWith, IteratorWith};
-    use handlers::extract::{ForwardSequence, FrontIteratorWith};
+    use handlers::extract::{extract, ForwardSequence, FrontIteratorWith};
     use hashbrown::hash_map::Entry;
     use if_chain::if_chain;
     use smallvec::SmallVec;
@@ -722,11 +740,36 @@ mod handlers {
         Ok(None)
     }
 
-    pub fn ret<'sc, 'vm>(mut cx: DispatchContext<'sc, 'vm>) -> Result<Option<HandleResult>, Unrooted> {
+    pub fn delayed_ret(mut cx: DispatchContext<'_, '_>) -> Result<Option<HandleResult>, Unrooted> {
+        let value = cx.pop_stack();
+        cx.active_frame_mut().delayed_ret = Some(Ok(value));
+        Ok(None)
+    }
+
+    pub fn finally_end<'sc, 'vm>(mut cx: DispatchContext<'sc, 'vm>) -> Result<Option<HandleResult>, Unrooted> {
         let tc_depth = cx.fetchw_and_inc_ip();
-        let value = cx.pop_stack_rooted();
-        let this = cx.pop_frame();
 
+        if let Some(ret) = cx.active_frame_mut().delayed_ret.take() {
+            let ret = ret?.root(cx.scope);
+            let frame_ip = cx.frames.len();
+            let enclosing_finally = cx
+                .try_blocks
+                .iter()
+                .find_map(|tc| if tc.frame_ip == frame_ip { tc.finally_ip } else { None });
+
+            if let Some(finally) = enclosing_finally {
+                let lower_tcp = cx.try_blocks.len() - usize::from(tc_depth);
+                drop(cx.try_blocks.drain(lower_tcp..));
+                cx.active_frame_mut().ip = finally;
+            } else {
+                let this = cx.pop_frame();
+                return Ok(ret_inner(cx, tc_depth, ret, this));
+            }
+        }
+        Ok(None)
+    }
+
+    fn ret_inner(mut cx: DispatchContext<'_, '_>, tc_depth: u16, value: Value, this: Frame) -> Option<HandleResult> {
         // Drain all try catch blocks that are in this frame.
         let lower_tcp = cx.try_blocks.len() - usize::from(tc_depth);
         drop(cx.try_blocks.drain(lower_tcp..));
@@ -738,7 +781,7 @@ mod handlers {
             FrameState::Module(_) => {
                 // Put it back on the frame stack, because we'll need it in Vm::execute_module
                 cx.frames.push(this);
-                Ok(Some(HandleResult::Return(Unrooted::new(value))))
+                Some(HandleResult::Return(Unrooted::new(value)))
             }
             FrameState::Function {
                 is_constructor_call,
@@ -752,17 +795,17 @@ mod handlers {
                         // return `this`
                         if is_flat_call {
                             cx.stack.push(this);
-                            Ok(None)
+                            None
                         } else {
-                            Ok(Some(HandleResult::Return(Unrooted::new(this))))
+                            Some(HandleResult::Return(Unrooted::new(this)))
                         }
                     }
                     else {
                         if is_flat_call {
                             cx.stack.push(value);
-                            Ok(None)
+                            None
                         } else {
-                            Ok(Some(HandleResult::Return(Unrooted::new(value))))
+                            Some(HandleResult::Return(Unrooted::new(value)))
                         }
                     }
                 }
@@ -770,8 +813,15 @@ mod handlers {
         }
     }
 
+    pub fn ret<'sc, 'vm>(mut cx: DispatchContext<'sc, 'vm>) -> Result<Option<HandleResult>, Unrooted> {
+        let tc_depth = cx.fetchw_and_inc_ip();
+        let value = cx.pop_stack_rooted();
+        let this = cx.pop_frame();
+        Ok(ret_inner(cx, tc_depth, value, this))
+    }
+
     pub fn ldglobal<'sc, 'vm>(mut cx: DispatchContext<'sc, 'vm>) -> Result<Option<HandleResult>, Unrooted> {
-        let id = cx.fetch_and_inc_ip();
+        let id = cx.fetchw_and_inc_ip();
         let name = cx.identifier_constant(id.into());
 
         let value = match cx.global.as_any().downcast_ref::<NamedObject>() {
@@ -1739,12 +1789,21 @@ mod handlers {
     }
 
     pub fn try_block<'sc, 'vm>(mut cx: DispatchContext<'sc, 'vm>) -> Result<Option<HandleResult>, Unrooted> {
-        let ip = cx.active_frame().ip;
-        let catch_offset = cx.fetchw_and_inc_ip() as usize;
-        let catch_ip = ip + catch_offset + 2;
+        let mut compute_dist_ip = || {
+            let distance = extract::<Option<u16>>(&mut cx)?;
+            let ip = cx.active_frame().ip;
+            Some(ip + distance as usize)
+        };
+
+        let catch_ip = compute_dist_ip();
+        let finally_ip = compute_dist_ip();
         let frame_ip = cx.frames.len();
 
-        cx.try_blocks.push(TryBlock { catch_ip, frame_ip });
+        cx.try_blocks.push(TryBlock {
+            catch_ip,
+            finally_ip,
+            frame_ip,
+        });
 
         Ok(None)
     }
@@ -2250,6 +2309,7 @@ pub fn handle(vm: &mut Vm, instruction: Instruction) -> Result<Option<HandleResu
         Instruction::StrictNe => handlers::strict_ne(cx),
         Instruction::Try => handlers::try_block(cx),
         Instruction::TryEnd => handlers::try_end(cx),
+        Instruction::FinallyEnd => handlers::finally_end(cx),
         Instruction::Throw => handlers::throw(cx),
         Instruction::Yield => handlers::yield_(cx),
         Instruction::JmpFalseNP => handlers::jmpfalsenp(cx),
@@ -2287,6 +2347,7 @@ pub fn handle(vm: &mut Vm, instruction: Instruction) -> Result<Option<HandleResu
         Instruction::ObjDestruct => handlers::objdestruct(cx),
         Instruction::ArrayDestruct => handlers::arraydestruct(cx),
         Instruction::AssignProperties => handlers::assign_properties(cx),
+        Instruction::DelayedReturn => handlers::delayed_ret(cx),
         Instruction::Nop => Ok(None),
         _ => unimplemented!("{:?}", instruction),
     }
diff --git a/crates/dash_vm/src/frame.rs b/crates/dash_vm/src/frame.rs
index 7ff910b2..efa0633e 100755
--- a/crates/dash_vm/src/frame.rs
+++ b/crates/dash_vm/src/frame.rs
@@ -15,13 +15,13 @@ use crate::value::{ExternalValue, Unrooted};
 use super::value::function::user::UserFunction;
 use super::value::Value;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct TryBlock {
-    pub catch_ip: usize,
+    pub catch_ip: Option<usize>,
+    pub finally_ip: Option<usize>,
     pub frame_ip: usize,
 }
 
-// TODO: these should be unrooted
 #[derive(Debug, Clone, Default)]
 pub struct Exports {
     pub default: Option<Unrooted>,
@@ -101,6 +101,10 @@ pub struct Frame {
     pub this: Option<Value>,
     pub sp: usize,
     pub state: FrameState,
+    /// When evaluating a `return` op in a try/catch with a finally block,
+    /// this will be set to Some(Ok(that_value)).
+    /// Exceptions thrown will set it to Err(exception).
+    pub delayed_ret: Option<Result<Unrooted, Unrooted>>,
 
     /// The `arguments` object.
     /// For optimization purposes, this is `None` in frames whose function never references `arguments`,
@@ -126,6 +130,7 @@ impl Frame {
             externals: uf.externals().clone(),
             ip: 0,
             sp: 0,
+            delayed_ret: None,
             extra_stack_space: inner.locals - uf.inner().params,
             state: FrameState::Function {
                 is_constructor_call,
@@ -144,6 +149,7 @@ impl Frame {
             externals: uf.externals().clone(),
             ip: 0,
             sp: 0,
+            delayed_ret: None,
             extra_stack_space: inner.locals - uf.inner().params,
             state: FrameState::Module(Exports::default()),
             loop_counter: LoopCounterMap::default(),
@@ -181,6 +187,7 @@ impl Frame {
             externals: Vec::new().into(),
             ip: 0,
             sp: 0,
+            delayed_ret: None,
             extra_stack_space: cr.locals, /* - 0 params */
             state: FrameState::Function {
                 is_constructor_call: false,
diff --git a/crates/dash_vm/src/gc/trace.rs b/crates/dash_vm/src/gc/trace.rs
index 048eac55..e3e74348 100644
--- a/crates/dash_vm/src/gc/trace.rs
+++ b/crates/dash_vm/src/gc/trace.rs
@@ -50,6 +50,14 @@ unsafe impl<T: Trace> Trace for Option<T> {
         }
     }
 }
+unsafe impl<T: Trace, E: Trace> Trace for Result<T, E> {
+    fn trace(&self, cx: &mut TraceCtxt<'_>) {
+        match self {
+            Ok(v) => v.trace(cx),
+            Err(v) => v.trace(cx),
+        }
+    }
+}
 unsafe impl Trace for Unrooted {
     fn trace(&self, cx: &mut TraceCtxt<'_>) {
         unsafe { self.get().trace(cx) }
diff --git a/crates/dash_vm/src/js_std/object.rs b/crates/dash_vm/src/js_std/object.rs
index f85694b9..48603da4 100644
--- a/crates/dash_vm/src/js_std/object.rs
+++ b/crates/dash_vm/src/js_std/object.rs
@@ -31,6 +31,7 @@ pub fn create(cx: CallContext) -> Result<Value, Value> {
 
 pub fn keys(cx: CallContext) -> Result<Value, Value> {
     let obj = cx.args.first().unwrap_or_undefined().to_object(cx.scope)?;
+    // FIXME: own_keys should probably takes an `enumerable: bool`
     let keys = obj.own_keys(cx.scope)?;
     let array = Array::from_vec(cx.scope, keys.into_iter().map(PropertyValue::static_default).collect());
     Ok(cx.scope.register(array).into())
diff --git a/crates/dash_vm/src/lib.rs b/crates/dash_vm/src/lib.rs
index 58adfd19..1be1a692 100644
--- a/crates/dash_vm/src/lib.rs
+++ b/crates/dash_vm/src/lib.rs
@@ -237,6 +237,8 @@ impl Vm {
             [
                 (sym::create, scope.statics.object_create.clone()),
                 (sym::keys, scope.statics.object_keys.clone()),
+                // FIXME: these are not the same
+                (sym::getOwnPropertyNames, scope.statics.object_keys.clone()),
                 (sym::getOwnPropertyDescriptor, scope.statics.object_get_own_property_descriptor.clone()),
                 (sym::getOwnPropertyDescriptors, scope.statics.object_get_own_property_descriptors.clone()),
                 (sym::defineProperty, scope.statics.object_define_property.clone()),
@@ -1289,10 +1291,8 @@ impl Vm {
         debug!("handling rt error @{max_fp}");
         // Using .last() here instead of .pop() because there is a possibility that we
         // can't use this block (read the comment above the if statement try_fp < max_fp)
-        if let Some(last) = self.try_blocks.last() {
+        if let Some(&TryBlock { catch_ip, finally_ip, frame_ip: try_fp }) = self.try_blocks.last() {
             // if we're in a try-catch block, we need to jump to it
-            let try_fp = last.frame_ip;
-            let catch_ip = last.catch_ip;
 
             // Do not unwind further than we are allowed to. If the last try block is "outside" of
             // the frame that this execution context was instantiated in, then we can't jump there.
@@ -1308,12 +1308,29 @@ impl Vm {
             // Unwind frames
             drop(self.frames.drain(try_fp..));
 
-            self.active_frame_mut().ip = catch_ip;
+            if let Some(catch_ip) = catch_ip {
+                self.active_frame_mut().ip = catch_ip;
 
-            let catch_ip = self.fetchw_and_inc_ip();
-            if catch_ip != u16::MAX {
-                // u16::MAX is used to indicate that there is no variable binding in the catch block
-                self.set_local(catch_ip as usize, err);
+                let catch_binding = self.fetchw_and_inc_ip();
+                if catch_binding != u16::MAX {
+                    // u16::MAX is used to indicate that there is no variable binding in the catch block
+                    self.set_local(catch_binding as usize, err);
+                }
+                
+                // If we have both a catch_ip and finally_ip, then re-push it but with the catch_ip set to None
+                // and then jump to the old catch_ip.
+                // Reason: when we then throw an exception within this catch, we correctly jump to the finally.
+                if let Some(finally_ip) = finally_ip {
+                    self.try_blocks.push(TryBlock{
+                        catch_ip: None,
+                        finally_ip: Some(finally_ip),
+                        frame_ip: try_fp
+                    });
+                }
+            } else if let Some(finally_ip) = finally_ip {
+                self.active_frame_mut().delayed_ret = Some(Err(err));
+                // `+ 1` because we need to jump over the `TryEnd` instruction since there won't be a try block to pop.
+                self.active_frame_mut().ip = finally_ip + 1;
             }
 
             Ok(())
diff --git a/crates/dash_vm/src/test/mod.rs b/crates/dash_vm/src/test/mod.rs
index f521e7e7..c5f3013e 100644
--- a/crates/dash_vm/src/test/mod.rs
+++ b/crates/dash_vm/src/test/mod.rs
@@ -450,3 +450,103 @@ simple_test!(
     "#,
     Value::undefined()
 );
+
+simple_test!(
+    try_finally,
+    r#"
+
+    let o = '';
+    assert((() => {
+        o += 1;
+        try {
+            o += 2;
+            return 1;
+        } catch {
+            o += 4;
+        } finally {
+            o += 3;
+        }
+    })() == 1);
+    assert(o === '123');
+
+
+    o = '';
+    assert((() => {
+        o += 1;
+        try {
+            o += 2;
+            return 1;
+        } catch {
+            o += 4;
+        } finally {
+            o += 3;
+            return 2;
+        }
+    })() == 2);
+    assert(o === '123');
+
+
+    o = '';
+    try {
+        o += 1;
+        try {
+            o += 2;
+            throw null;
+        } catch {
+            o += 3;
+        } finally {
+            o += 4;
+        }
+    } catch(e) {
+        // exception was already caught by the inner catch
+        o += 5;
+    } finally {
+        o += 6;
+    }
+    assert(o === '12346');
+
+
+    o = '';
+    try {
+        o += 1;
+        try {
+            o += 2;
+            throw null;
+        } catch(e) {
+            o += 3;
+            throw e;
+        } finally {
+            o += 4;
+        }
+    } catch(e) {
+        // inner exception rethrown, we should catch it here
+        assert(e === null);
+        o += 5;
+    } finally {
+        o += 6;
+    }
+    assert(o === '123456');
+
+    o = '';
+    assert((() => {
+        try {
+            try {
+                o += 1;
+                return 1;
+            } catch(e) {
+                o += 2;
+            } finally {
+                o += 3;
+                // DONT return here just yet
+            }
+            o += 4;
+        } finally {
+            o += 5;
+            return 5;
+        }
+    })() === 5);
+    assert(o === '135');
+
+    "#,
+    Value::undefined()
+);