refactor: 拆分 Kernel 中可变 Session 与不可变 Core

crates/oxide_vm/src/bindings/bind_array.rs

@@ -1,11 +1,12 @@
 use std::sync::Arc;
 
-use crate::bind_constructor_hash;
 use oxide_kernel::builtin::ArrayMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
-pub fn bind_array(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+use crate::bind_constructor_hash;
+
+pub fn bind_array(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let _array_methods = ArrayMethods {
         is_array: crate::builtins::array::array_is_array as *const (),
         push: crate::builtins::array::array_push as *const (),
@@ -38,12 +39,12 @@ pub fn bind_array(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         sort: crate::builtins::array::array_sort as *const (),
     };
 
-    kernel.builtin_world().bind_array_methods(
+    session.builtin_world().bind_array_methods(
         &_array_methods,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
     );
 
-    let ctor_ptr = kernel.builtin_world().array_constructor.as_ptr() as *mut JsObject;
-    bind_constructor_hash!(kernel, global, "Array", ctor_ptr, crate::builtins::array::array_constructor, 1);
+    let ctor_ptr = session.builtin_world().array_constructor.as_ptr() as *mut JsObject;
+    bind_constructor_hash!(core, global, "Array", ctor_ptr, crate::builtins::array::array_constructor, 1);
 }

crates/oxide_vm/src/bindings/bind_boolean.rs

@@ -2,26 +2,26 @@ use std::sync::Arc;
 
 use crate::bind_constructor_hash;
 use crate::bindings::{apply_binding_table, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
-pub fn bind_boolean(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().boolean_constructor.as_ptr() as *mut JsObject;
+pub fn bind_boolean(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().boolean_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().boolean_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().boolean_proto.as_ptr() as *mut JsObject;
     let proto = unsafe { &mut *proto_ptr };
 
     configure_native_constructor(ctor, crate::builtins::boolean::boolean_constructor as *const (), 1);
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[
             ("valueOf", crate::builtins::boolean::boolean_prototype_value_of as *const (), 0),
             ("toString", crate::builtins::boolean::boolean_prototype_to_string as *const (), 0),
         ],
     );
 
-    bind_constructor_hash!(kernel, global, "Boolean", ctor_ptr, crate::builtins::boolean::boolean_constructor, 1);
+    bind_constructor_hash!(core, global, "Boolean", ctor_ptr, crate::builtins::boolean::boolean_constructor, 1);
 }

crates/oxide_vm/src/bindings/bind_date.rs

@@ -1,22 +1,22 @@
 use std::sync::Arc;
 
 use crate::bindings::{apply_binding_table, bind_global_value, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
-pub fn bind_date(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().date_constructor.as_ptr() as *mut JsObject;
+pub fn bind_date(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().date_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().date_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().date_proto.as_ptr() as *mut JsObject;
     let proto = unsafe { &mut *proto_ptr };
 
     configure_native_constructor(ctor, crate::builtins::date::date_constructor as *const (), 7);
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         ctor,
-        kernel,
+        core,
         &[
             ("now", crate::builtins::date::date_now as *const (), 0),
             ("parse", crate::builtins::date::date_parse as *const (), 1),
@@ -25,9 +25,9 @@ pub fn bind_date(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     );
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[
             ("getTime", crate::builtins::date::date_get_time as *const (), 0),
             ("getFullYear", crate::builtins::date::date_get_full_year as *const (), 0),
@@ -65,5 +65,5 @@ pub fn bind_date(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         ],
     );
 
-    bind_global_value(kernel, global, "Date", JsValue::from_js_object(ctor_ptr));
+    bind_global_value(core, global, "Date", JsValue::from_js_object(ctor_ptr));
 }

crates/oxide_vm/src/bindings/bind_error.rs

@@ -1,17 +1,18 @@
 use std::sync::Arc;
 
 use oxide_kernel::builtin::ErrorMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
 use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 fn bind_error_subtype_constructor(
-    kernel: &Arc<OxideKernel>, global: &mut JsObject, name: &str, proto_ptr: *mut JsObject, ctor_fn: *const (),
+    core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject, name: &str, proto_ptr: *mut JsObject,
+    ctor_fn: *const (),
 ) {
-    let sf = kernel.string_forge().as_ref();
-    let sh = kernel.shape_forge().as_ref();
-    let function_proto_ptr = kernel.builtin_world().function_proto.as_ptr() as *mut JsObject;
+    let sf = core.string_forge().as_ref();
+    let sh = core.shape_forge().as_ref();
+    let function_proto_ptr = session.builtin_world().function_proto.as_ptr() as *mut JsObject;
 
     let mut ctor = Box::new(JsObject::new_empty(EMPTY_SHAPE_ID, JsValue::from_js_object(function_proto_ptr)));
     ctor.set_function(true);
@@ -42,7 +43,7 @@ fn bind_error_subtype_constructor(
     global.bump_generation();
 }
 
-pub fn bind_error(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+pub fn bind_error(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let error_methods = ErrorMethods {
         error: crate::builtins::error::error_constructor as *const (),
         type_error: crate::builtins::error::type_error_constructor as *const (),
@@ -54,64 +55,70 @@ pub fn bind_error(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         to_string: crate::builtins::error::error_to_string as *const (),
         stack: crate::builtins::error::error_stack_getter as *const (),
     };
-    kernel.builtin_world().bind_error_methods(
+    session.builtin_world().bind_error_methods(
         &error_methods,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
     );
 
-    let si_err = kernel.string_forge().intern("Error").0;
-    let err_shape = kernel.shape_forge().make_shape(global.shape_id(), si_err);
-    let err_val = JsValue::from_js_object(kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject);
+    let si_err = core.string_forge().intern("Error").0;
+    let err_shape = core.shape_forge().make_shape(global.shape_id(), si_err);
+    let err_val = JsValue::from_js_object(session.builtin_world().error_constructor.as_ptr() as *mut JsObject);
     global.set_shape_id(err_shape);
     global.ensure_hash_props().push(err_val);
     global.bump_generation();
 
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "TypeError",
-        kernel.builtin_world().type_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().type_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::type_error_constructor as *const (),
     );
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "ReferenceError",
-        kernel.builtin_world().reference_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().reference_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::reference_error_constructor as *const (),
     );
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "RangeError",
-        kernel.builtin_world().range_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().range_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::range_error_constructor as *const (),
     );
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "SyntaxError",
-        kernel.builtin_world().syntax_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().syntax_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::syntax_error_constructor as *const (),
     );
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "URIError",
-        kernel.builtin_world().uri_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().uri_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::uri_error_constructor as *const (),
     );
     bind_error_subtype_constructor(
-        kernel,
+        core,
+        session,
         global,
         "EvalError",
-        kernel.builtin_world().eval_error_proto.as_ptr() as *mut JsObject,
+        session.builtin_world().eval_error_proto.as_ptr() as *mut JsObject,
         crate::builtins::error::eval_error_constructor as *const (),
     );
 
     {
-        let err_ctor_ptr = kernel.builtin_world().error_constructor.as_ptr() as *mut JsObject;
+        let err_ctor_ptr = session.builtin_world().error_constructor.as_ptr() as *mut JsObject;
         let err_ctor = unsafe { &mut *err_ctor_ptr };
         // SAFETY: error_constructor is a NativeFn fn-item.
         err_ctor.set_native_fn(Some(unsafe {

crates/oxide_vm/src/bindings/bind_function.rs

@@ -1,25 +1,25 @@
 use std::sync::Arc;
 
 use oxide_kernel::builtin::FunctionMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
 use super::bind_global_value;
 
-pub fn bind_function(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+pub fn bind_function(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let function_methods = FunctionMethods {
         call: crate::builtins::function::function_call as *const (),
         apply: crate::builtins::function::function_apply as *const (),
         bind: crate::builtins::function::function_bind as *const (),
         to_string: crate::builtins::function::function_to_string as *const (),
     };
-    kernel.builtin_world().bind_function_methods(
+    session.builtin_world().bind_function_methods(
         &function_methods,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
     );
 
-    let function_ctor = kernel.builtin_world().function_constructor.as_ptr() as *mut JsObject;
-    bind_global_value(kernel, global, "Function", JsValue::from_js_object(function_ctor));
+    let function_ctor = session.builtin_world().function_constructor.as_ptr() as *mut JsObject;
+    bind_global_value(core, global, "Function", JsValue::from_js_object(function_ctor));
 }

crates/oxide_vm/src/bindings/bind_json.rs

@@ -1,18 +1,18 @@
 use std::sync::Arc;
 
 use crate::bindings::{apply_binding_table, bind_global_value};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
-pub fn bind_json(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let json_ptr = kernel.builtin_world().json_object.as_ptr() as *mut JsObject;
+pub fn bind_json(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let json_ptr = session.builtin_world().json_object.as_ptr() as *mut JsObject;
     let json = unsafe { &mut *json_ptr };
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         json,
-        kernel,
+        core,
         &[
             ("parse", crate::builtins::json::json_parse as *const (), 1),
             ("stringify", crate::builtins::json::json_stringify as *const (), 1),
@@ -20,9 +20,9 @@ pub fn bind_json(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     );
 
     bind_global_value(
-        kernel,
+        core,
         global,
         "JSON",
-        JsValue::from_js_object(kernel.builtin_world().json_object.as_ptr() as *mut JsObject),
+        JsValue::from_js_object(session.builtin_world().json_object.as_ptr() as *mut JsObject),
     );
 }

crates/oxide_vm/src/bindings/bind_map.rs

@@ -2,21 +2,21 @@ use std::sync::Arc;
 
 use crate::bind_constructor_hash;
 use crate::bindings::{apply_binding_table, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
-pub fn bind_map(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().map_constructor.as_ptr() as *mut JsObject;
+pub fn bind_map(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().map_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().map_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().map_proto.as_ptr() as *mut JsObject;
 
     configure_native_constructor(ctor, crate::builtins::map::map_constructor as *const (), 1);
     let proto = unsafe { &mut *proto_ptr };
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[
             ("set", crate::builtins::map::map_set as *const (), 2),
             ("get", crate::builtins::map::map_get as *const (), 1),
@@ -27,5 +27,5 @@ pub fn bind_map(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         ],
     );
 
-    bind_constructor_hash!(kernel, global, "Map", ctor_ptr, crate::builtins::map::map_constructor, 1);
+    bind_constructor_hash!(core, global, "Map", ctor_ptr, crate::builtins::map::map_constructor, 1);
 }

crates/oxide_vm/src/bindings/bind_math.rs

@@ -1,17 +1,17 @@
 use std::sync::Arc;
 
 use oxide_kernel::bind_methods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
-pub fn bind_math(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let math_ptr = kernel.builtin_world().math_object.as_ptr() as *mut JsObject;
+pub fn bind_math(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let math_ptr = session.builtin_world().math_object.as_ptr() as *mut JsObject;
     let math = unsafe { &mut *math_ptr };
 
-    let bw = kernel.builtin_world();
-    let sf = kernel.string_forge().as_ref();
-    let sh = kernel.shape_forge().as_ref();
+    let bw = session.builtin_world();
+    let sf = core.string_forge().as_ref();
+    let sh = core.shape_forge().as_ref();
 
     bind_methods!(
         bw,
@@ -65,15 +65,15 @@ pub fn bind_math(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         ("SQRT1_2", std::f64::consts::FRAC_1_SQRT_2),
         ("SQRT2", std::f64::consts::SQRT_2),
     ] {
-        let si = kernel.string_forge().as_ref().intern(name).0;
-        let sh_c = kernel.shape_forge().as_ref().make_shape(math.shape_id(), si);
+        let si = core.string_forge().as_ref().intern(name).0;
+        let sh_c = core.shape_forge().as_ref().make_shape(math.shape_id(), si);
         math.set_shape_id(sh_c);
         math.ensure_hash_props().push(JsValue::float(val));
     }
 
-    let si_m = kernel.string_forge().intern("Math").0;
-    let m_shape = kernel.shape_forge().make_shape(global.shape_id(), si_m);
-    let m_val = JsValue::from_js_object(kernel.builtin_world().math_object.as_ptr() as *mut JsObject);
+    let si_m = core.string_forge().intern("Math").0;
+    let m_shape = core.shape_forge().make_shape(global.shape_id(), si_m);
+    let m_val = JsValue::from_js_object(session.builtin_world().math_object.as_ptr() as *mut JsObject);
     global.set_shape_id(m_shape);
     global.ensure_hash_props().push(m_val);
     global.bump_generation();

crates/oxide_vm/src/bindings/bind_number.rs

@@ -2,11 +2,11 @@ use std::sync::Arc;
 
 use oxide_kernel::bind_methods;
 use oxide_kernel::builtin::NumberMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
-pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+pub fn bind_number(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let number_methods = NumberMethods {
         is_nan: crate::builtins::number::number_is_nan as *const (),
         is_finite: crate::builtins::number::number_is_finite as *const (),
@@ -20,21 +20,21 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         to_precision: crate::builtins::number::number_to_precision as *const (),
         value_of: crate::builtins::number::number_value_of as *const (),
     };
-    kernel.builtin_world().bind_number_methods(
+    session.builtin_world().bind_number_methods(
         &number_methods,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
     );
 
-    let si_num = kernel.string_forge().intern("Number").0;
-    let num_shape = kernel.shape_forge().make_shape(global.shape_id(), si_num);
-    let num_val = JsValue::from_js_object(kernel.builtin_world().number_constructor.as_ptr() as *mut JsObject);
+    let si_num = core.string_forge().intern("Number").0;
+    let num_shape = core.shape_forge().make_shape(global.shape_id(), si_num);
+    let num_val = JsValue::from_js_object(session.builtin_world().number_constructor.as_ptr() as *mut JsObject);
     global.set_shape_id(num_shape);
     global.ensure_hash_props().push(num_val);
     global.bump_generation();
 
     {
-        let num_ctor_ptr = kernel.builtin_world().number_constructor.as_ptr() as *mut JsObject;
+        let num_ctor_ptr = session.builtin_world().number_constructor.as_ptr() as *mut JsObject;
         let num_ctor = unsafe { &mut *num_ctor_ptr };
         // SAFETY: number_constructor is a NativeFn fn-item.
         num_ctor.set_native_fn(Some(unsafe {
@@ -53,8 +53,8 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
             ("POSITIVE_INFINITY", JsValue::float(f64::INFINITY)),
         ] {
             num_ctor.ensure_hash_props().push(value);
-            let prop_si = kernel.string_forge().intern(name).0;
-            let next_shape = kernel.shape_forge().make_shape(num_ctor.shape_id(), prop_si);
+            let prop_si = core.string_forge().intern(name).0;
+            let next_shape = core.shape_forge().make_shape(num_ctor.shape_id(), prop_si);
             num_ctor.set_shape_id(next_shape);
         }
     }
@@ -62,10 +62,10 @@ pub fn bind_number(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
     let pi_fn = crate::builtins::number::number_parse_int as *const ();
     let pf_fn = crate::builtins::number::number_parse_float as *const ();
     bind_methods!(
-        kernel.builtin_world(),
+        session.builtin_world(),
         global,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
         ("parseInt", pi_fn, 1),
         ("parseFloat", pf_fn, 1),
     );

crates/oxide_vm/src/bindings/bind_object.rs

@@ -1,11 +1,12 @@
 use std::sync::Arc;
 
-use crate::bind_constructor;
 use oxide_kernel::builtin::ObjectMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
-pub fn bind_object(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+use crate::bind_constructor;
+
+pub fn bind_object(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let methods = ObjectMethods {
         keys: crate::builtins::object::object_keys as *const (),
         create: crate::builtins::object::object_create as *const (),
@@ -29,10 +30,10 @@ pub fn bind_object(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         has_own_property: crate::builtins::object::object_proto_has_own_property as *const (),
         property_is_enumerable: crate::builtins::object::object_proto_property_is_enumerable as *const (),
     };
-    kernel
+    session
         .builtin_world()
-        .bind_object_methods(&methods, kernel.string_forge().as_ref(), kernel.shape_forge().as_ref());
+        .bind_object_methods(&methods, core.string_forge().as_ref(), core.shape_forge().as_ref());
 
-    let ctor_ptr = kernel.builtin_world().object_constructor.as_ptr() as *mut JsObject;
-    bind_constructor!(kernel, global, "Object", ctor_ptr, crate::builtins::object::object_constructor, 1);
+    let ctor_ptr = session.builtin_world().object_constructor.as_ptr() as *mut JsObject;
+    bind_constructor!(core, global, "Object", ctor_ptr, crate::builtins::object::object_constructor, 1);
 }

crates/oxide_vm/src/bindings/bind_regexp.rs

@@ -1,23 +1,23 @@
 use std::sync::Arc;
 
 use crate::bindings::{apply_binding_table, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
 use crate::bind_constructor_hash;
 
-pub fn bind_regexp(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().regexp_constructor.as_ptr() as *mut JsObject;
+pub fn bind_regexp(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().regexp_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().regexp_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().regexp_proto.as_ptr() as *mut JsObject;
     let proto = unsafe { &mut *proto_ptr };
 
     configure_native_constructor(ctor, crate::builtins::regexp::regexp_constructor as *const (), 2);
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[
             ("exec", crate::builtins::regexp::regexp_exec as *const (), 1),
             ("test", crate::builtins::regexp::regexp_test as *const (), 1),
@@ -25,5 +25,5 @@ pub fn bind_regexp(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         ],
     );
 
-    bind_constructor_hash!(kernel, global, "RegExp", ctor_ptr, crate::builtins::regexp::regexp_constructor, 2);
+    bind_constructor_hash!(core, global, "RegExp", ctor_ptr, crate::builtins::regexp::regexp_constructor, 2);
 }

crates/oxide_vm/src/bindings/bind_set.rs

@@ -2,21 +2,21 @@ use std::sync::Arc;
 
 use crate::bind_constructor_hash;
 use crate::bindings::{apply_binding_table, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 
-pub fn bind_set(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().set_constructor.as_ptr() as *mut JsObject;
+pub fn bind_set(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().set_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().set_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().set_proto.as_ptr() as *mut JsObject;
 
     configure_native_constructor(ctor, crate::builtins::set::set_constructor as *const (), 1);
     let proto = unsafe { &mut *proto_ptr };
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[
             ("add", crate::builtins::set::set_add as *const (), 1),
             ("has", crate::builtins::set::set_has as *const (), 1),
@@ -26,5 +26,5 @@ pub fn bind_set(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         ],
     );
 
-    bind_constructor_hash!(kernel, global, "Set", ctor_ptr, crate::builtins::set::set_constructor, 1);
+    bind_constructor_hash!(core, global, "Set", ctor_ptr, crate::builtins::set::set_constructor, 1);
 }

crates/oxide_vm/src/bindings/bind_string.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
 use oxide_kernel::builtin::StringMethods;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
-pub fn bind_string(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
+pub fn bind_string(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
     let string_methods = StringMethods {
         index_of: crate::builtins::string::string_index_of as *const (),
         includes: crate::builtins::string::string_includes as *const (),
@@ -34,15 +34,15 @@ pub fn bind_string(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
         replace_all: crate::builtins::string::string_replace_all as *const (),
         value_of: crate::builtins::string::string_value_of as *const (),
     };
-    kernel.builtin_world().bind_string_methods(
+    session.builtin_world().bind_string_methods(
         &string_methods,
-        kernel.string_forge().as_ref(),
-        kernel.shape_forge().as_ref(),
+        core.string_forge().as_ref(),
+        core.shape_forge().as_ref(),
     );
 
-    let si_str = kernel.string_forge().intern("String").0;
-    let str_shape = kernel.shape_forge().make_shape(global.shape_id(), si_str);
-    let str_val = JsValue::from_js_object(kernel.builtin_world().string_constructor.as_ptr() as *mut JsObject);
+    let si_str = core.string_forge().intern("String").0;
+    let str_shape = core.shape_forge().make_shape(global.shape_id(), si_str);
+    let str_val = JsValue::from_js_object(session.builtin_world().string_constructor.as_ptr() as *mut JsObject);
     global.set_shape_id(str_shape);
     global.ensure_hash_props().push(str_val);
     global.bump_generation();

crates/oxide_vm/src/bindings/bind_symbol.rs

@@ -1,58 +1,58 @@
 use std::sync::Arc;
 
 use crate::bindings::{apply_binding_table, configure_native_constructor};
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::JsObject;
 use oxide_types::value::JsValue;
 
 use crate::bind_constructor_hash;
 
-pub fn bind_symbol(kernel: &Arc<OxideKernel>, global: &mut JsObject) {
-    let ctor_ptr = kernel.builtin_world().symbol_constructor.as_ptr() as *mut JsObject;
+pub fn bind_symbol(core: &Arc<KernelCore>, session: &KernelSession, global: &mut JsObject) {
+    let ctor_ptr = session.builtin_world().symbol_constructor.as_ptr() as *mut JsObject;
     let ctor = unsafe { &mut *ctor_ptr };
-    let proto_ptr = kernel.builtin_world().symbol_proto.as_ptr() as *mut JsObject;
+    let proto_ptr = session.builtin_world().symbol_proto.as_ptr() as *mut JsObject;
     let proto = unsafe { &mut *proto_ptr };
 
     configure_native_constructor(ctor, crate::builtins::symbol::symbol_constructor as *const (), 1);
 
     apply_binding_table(
-        kernel.builtin_world(),
+        session.builtin_world(),
         proto,
-        kernel,
+        core,
         &[("toString", crate::builtins::symbol::symbol_to_string as *const (), 0)],
     );
 
     for (name, val) in [
         (
             "match",
-            JsValue::from_js_object(kernel.builtin_world().sym_match.as_ptr() as *mut JsObject),
+            JsValue::from_js_object(session.builtin_world().sym_match.as_ptr() as *mut JsObject),
         ),
         (
             "replace",
-            JsValue::from_js_object(kernel.builtin_world().sym_replace.as_ptr() as *mut JsObject),
+            JsValue::from_js_object(session.builtin_world().sym_replace.as_ptr() as *mut JsObject),
         ),
         (
             "search",
-            JsValue::from_js_object(kernel.builtin_world().sym_search.as_ptr() as *mut JsObject),
+            JsValue::from_js_object(session.builtin_world().sym_search.as_ptr() as *mut JsObject),
         ),
         (
             "split",
-            JsValue::from_js_object(kernel.builtin_world().sym_split.as_ptr() as *mut JsObject),
+            JsValue::from_js_object(session.builtin_world().sym_split.as_ptr() as *mut JsObject),
         ),
         (
             "iterator",
-            JsValue::from_js_object(kernel.builtin_world().sym_iterator.as_ptr() as *mut JsObject),
+            JsValue::from_js_object(session.builtin_world().sym_iterator.as_ptr() as *mut JsObject),
         ),
     ] {
-        bind_well_known_symbol(kernel, ctor, name, val);
+        bind_well_known_symbol(core, ctor, name, val);
     }
 
-    bind_constructor_hash!(kernel, global, "Symbol", ctor_ptr, crate::builtins::symbol::symbol_constructor, 1);
+    bind_constructor_hash!(core, global, "Symbol", ctor_ptr, crate::builtins::symbol::symbol_constructor, 1);
 }
 
-fn bind_well_known_symbol(kernel: &Arc<OxideKernel>, ctor: &mut JsObject, name: &str, val: JsValue) {
-    let si = kernel.string_forge().intern(name).0;
-    let shape_id = kernel.shape_forge().make_shape(ctor.shape_id(), si);
+fn bind_well_known_symbol(core: &Arc<KernelCore>, ctor: &mut JsObject, name: &str, val: JsValue) {
+    let si = core.string_forge().intern(name).0;
+    let shape_id = core.shape_forge().make_shape(ctor.shape_id(), si);
     ctor.set_shape_id(shape_id);
     ctor.ensure_hash_props().push(val);
     ctor.bump_generation();

crates/oxide_vm/src/bindings/mod.rs

@@ -16,15 +16,15 @@ pub mod bind_symbol;
 use std::sync::Arc;
 
 use oxide_kernel::builtin::BuiltinWorld;
-use oxide_kernel::kernel::OxideKernel;
+use oxide_kernel::kernel::{KernelCore, KernelSession};
 use oxide_types::object::{JsObject, NativeFnPtr};
 use oxide_types::value::JsValue;
 
 #[macro_export]
 macro_rules! bind_constructor {
-    ($kernel:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{
-        let si = $kernel.string_forge().intern($name).0;
-        let shape = $kernel.shape_forge().make_shape($global.shape_id(), si);
+    ($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{
+        let si = $core.string_forge().intern($name).0;
+        let shape = $core.shape_forge().make_shape($global.shape_id(), si);
         let val = $crate::JsValue::from_js_object($ctor_ptr);
         $global.set_shape_id(shape);
         $global.push_prop(val);
@@ -37,9 +37,9 @@ macro_rules! bind_constructor {
 
 #[macro_export]
 macro_rules! bind_constructor_hash {
-    ($kernel:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{
-        let si = $kernel.string_forge().intern($name).0;
-        let shape = $kernel.shape_forge().make_shape($global.shape_id(), si);
+    ($core:expr, $global:expr, $name:literal, $ctor_ptr:expr, $ctor_fn:path, $nargs:literal) => {{
+        let si = $core.string_forge().intern($name).0;
+        let shape = $core.shape_forge().make_shape($global.shape_id(), si);
         let val = $crate::JsValue::from_js_object($ctor_ptr);
         $global.set_shape_id(shape);
         $global.ensure_hash_props().push(val);
@@ -58,10 +58,10 @@ pub(crate) fn configure_native_constructor(ctor: &mut JsObject, native_fn: *cons
 }
 
 pub(crate) fn apply_binding_table(
-    world: &BuiltinWorld, target: &mut JsObject, kernel: &Arc<OxideKernel>, bindings: &[(&'static str, *const (), u8)],
+    world: &BuiltinWorld, target: &mut JsObject, core: &Arc<KernelCore>, bindings: &[(&'static str, *const (), u8)],
 ) {
-    let shape_forge = kernel.shape_forge().as_ref();
-    let string_forge = kernel.string_forge().as_ref();
+    let shape_forge = core.shape_forge().as_ref();
+    let string_forge = core.string_forge().as_ref();
     for (name, func, nargs) in bindings {
         // SAFETY: all entries in the binding table are NativeFn fn-item pointers cast to *const ().
         let fn_ptr = unsafe { oxide_types::object::NativeFnPtr::from_raw(*func) };
@@ -69,32 +69,32 @@ pub(crate) fn apply_binding_table(
     }
 }
 
-pub(crate) fn bind_global_value(kernel: &Arc<OxideKernel>, global: &mut JsObject, name: &str, value: JsValue) {
-    let si = kernel.string_forge().intern(name).0;
-    let shape = kernel.shape_forge().make_shape(global.shape_id(), si);
+pub(crate) fn bind_global_value(core: &Arc<KernelCore>, global: &mut JsObject, name: &str, value: JsValue) {
+    let si = core.string_forge().intern(name).0;
+    let shape = core.shape_forge().make_shape(global.shape_id(), si);
     global.set_shape_id(shape);
     global.ensure_hash_props().push(value);
     global.bump_generation();
 }
 
-pub fn init_kernel_builtins(kernel: &Arc<OxideKernel>) {
-    let global_ptr = kernel.global_object().as_ptr() as *mut oxide_types::object::JsObject;
+pub fn init_kernel_builtins(core: &Arc<KernelCore>, session: &KernelSession) {
+    let global_ptr = session.global_object().as_ptr() as *mut oxide_types::object::JsObject;
     let global = unsafe { &mut *global_ptr };
 
-    bind_object::bind_object(kernel, global);
-    bind_array::bind_array(kernel, global);
-    bind_error::bind_error(kernel, global);
-    bind_string::bind_string(kernel, global);
-    bind_number::bind_number(kernel, global);
-    bind_math::bind_math(kernel, global);
-    bind_json::bind_json(kernel, global);
-    bind_date::bind_date(kernel, global);
-    bind_set::bind_set(kernel, global);
-    bind_map::bind_map(kernel, global);
-    bind_boolean::bind_boolean(kernel, global);
-    bind_function::bind_function(kernel, global);
-    bind_regexp::bind_regexp(kernel, global);
-    bind_symbol::bind_symbol(kernel, global);
+    bind_object::bind_object(core, session, global);
+    bind_array::bind_array(core, session, global);
+    bind_error::bind_error(core, session, global);
+    bind_string::bind_string(core, session, global);
+    bind_number::bind_number(core, session, global);
+    bind_math::bind_math(core, session, global);
+    bind_json::bind_json(core, session, global);
+    bind_date::bind_date(core, session, global);
+    bind_set::bind_set(core, session, global);
+    bind_map::bind_map(core, session, global);
+    bind_boolean::bind_boolean(core, session, global);
+    bind_function::bind_function(core, session, global);
+    bind_regexp::bind_regexp(core, session, global);
+    bind_symbol::bind_symbol(core, session, global);
 
-    bind_global_value(kernel, global, "globalThis", JsValue::from_js_object(global_ptr));
+    bind_global_value(core, global, "globalThis", JsValue::from_js_object(global_ptr));
 }