feat: register_external_functions() — set ext funcs without clearing state (#7)

parcadei · web-flow · commit 0c85b5ca5e7f · 2026-03-29T20:06:07.000+01:00
feat: register_external_functions() — set ext funcs without clearing state
diff --git a/Cargo.toml b/Cargo.toml
@@ -13,7 +13,7 @@ default-members = ["crates/ouros-cli"]
 
 [workspace.package]
 edition = "2024"
-version = "0.0.4"
+version = "0.0.6"
 rust-version = "1.90"
 license = "MIT"
 authors = ["parcadei <227596144+parcadei@users.noreply.github.com>"]
diff --git a/crates/ouros-js/package.json b/crates/ouros-js/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ouros",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "type": "module",
   "description": "Sandboxed Python interpreter for JavaScript/TypeScript",
   "main": "wrapper.js",
diff --git a/crates/ouros-python/python/ouros/session.py b/crates/ouros-python/python/ouros/session.py
@@ -126,6 +126,13 @@ def reset(self, *, external_functions: list[str] | None = None) -> None:
         """Reset this session to a fresh state."""
         self._manager._native.reset(session_id=self._id, external_functions=external_functions)
 
+    def register_external_functions(self, external_functions: list[str]) -> list[str]:
+        """Register additional external functions without clearing session state.
+
+        Returns names skipped due to collision with existing user variables.
+        """
+        return self._manager.register_external_functions(external_functions, session_id=self._id)
+
     def __repr__(self) -> str:
         return f'Session(id={self._id!r})'
 
@@ -264,6 +271,18 @@ def reset(self, *, session_id: str | None = None, external_functions: list[str]
         """Reset a session to a fresh state."""
         self._native.reset(session_id=session_id, external_functions=external_functions)
 
+    def register_external_functions(
+        self,
+        external_functions: list[str],
+        *,
+        session_id: str | None = None,
+    ) -> list[str]:
+        """Register additional external functions without clearing session state.
+
+        Returns names skipped due to collision with existing user variables.
+        """
+        return self._native.register_external_functions(external_functions, session_id=session_id)
+
     # -- Cross-session pipeline ------------------------------------------------
 
     def call_session(
diff --git a/crates/ouros-python/src/session_manager.rs b/crates/ouros-python/src/session_manager.rs
@@ -337,6 +337,21 @@ impl PySessionManager {
         Ok(())
     }
 
+    /// Register additional external functions without clearing session state.
+    ///
+    /// Functions already registered are silently skipped. Names that collide
+    /// with existing user variables are skipped and returned.
+    #[pyo3(signature = (external_functions, *, session_id=None))]
+    fn register_external_functions(
+        &mut self,
+        external_functions: Vec<String>,
+        session_id: Option<&str>,
+    ) -> PyResult<Vec<String>> {
+        self.inner
+            .register_external_functions(session_id, external_functions)
+            .map_err(session_err_to_py)
+    }
+
     // -------------------------------------------------------------------------
     // Persistence
     // -------------------------------------------------------------------------
@@ -542,22 +557,44 @@ fn progress_to_dict<'py>(py: Python<'py>, progress: &ReplProgress) -> PyResult<B
             dict.set_item("result", json_to_py(py, &json_val)?)?;
         }
         ReplProgress::FunctionCall {
-            function_name, call_id, ..
+            function_name,
+            call_id,
+            args,
+            kwargs,
         } => {
             dict.set_item("status", "function_call")?;
             dict.set_item("function_name", function_name)?;
             dict.set_item("call_id", call_id)?;
+            let py_args: PyResult<Vec<Py<PyAny>>> = args.iter().map(|a| json_to_py(py, &a.to_json_value())).collect();
+            dict.set_item("args", PyList::new(py, py_args?)?)?;
+            let kw_dict = PyDict::new(py);
+            for (k, v) in kwargs {
+                let key = json_to_py(py, &k.to_json_value())?;
+                let val = json_to_py(py, &v.to_json_value())?;
+                kw_dict.set_item(key, val)?;
+            }
+            dict.set_item("kwargs", kw_dict)?;
         }
         ReplProgress::ProxyCall {
             proxy_id,
             method,
             call_id,
-            ..
+            args,
+            kwargs,
         } => {
             dict.set_item("status", "proxy_call")?;
             dict.set_item("proxy_id", proxy_id)?;
             dict.set_item("method", method)?;
             dict.set_item("call_id", call_id)?;
+            let py_args: PyResult<Vec<Py<PyAny>>> = args.iter().map(|a| json_to_py(py, &a.to_json_value())).collect();
+            dict.set_item("args", PyList::new(py, py_args?)?)?;
+            let kw_dict = PyDict::new(py);
+            for (k, v) in kwargs {
+                let key = json_to_py(py, &k.to_json_value())?;
+                let val = json_to_py(py, &v.to_json_value())?;
+                kw_dict.set_item(key, val)?;
+            }
+            dict.set_item("kwargs", kw_dict)?;
         }
         ReplProgress::ResolveFutures { pending_call_ids, .. } => {
             dict.set_item("status", "resolve_futures")?;
diff --git a/crates/ouros/src/modules/codecs_mod.rs b/crates/ouros/src/modules/codecs_mod.rs
@@ -2235,7 +2235,7 @@ fn decode_utf16_ex(data: &[u8], errors: &str, byteorder: i64, final_flag: bool)
     }
 
     let mut out = String::new();
-    for decoded in char::decode_utf16(units.into_iter()) {
+    for decoded in char::decode_utf16(units) {
         match decoded {
             Ok(ch) => out.push(ch),
             Err(_) => match errors {
@@ -2430,7 +2430,7 @@ fn decode_utf7(data: &[u8], errors: &str, _final_flag: bool) -> RunResult<(Strin
                 units.push(u16::from_be_bytes([decoded_bytes[j], decoded_bytes[j + 1]]));
                 j += 2;
             }
-            for ch in char::decode_utf16(units.into_iter()) {
+            for ch in char::decode_utf16(units) {
                 match ch {
                     Ok(ch) => out.push(ch),
                     Err(_) => match errors {
diff --git a/crates/ouros/src/modules/itertools.rs b/crates/ouros/src/modules/itertools.rs
@@ -350,7 +350,7 @@ fn itertools_chain(heap: &mut Heap<impl ResourceTracker>, interns: &Interns, arg
         iter.drop_with_heap(heap);
 
         // items contains owned values - transfer ownership to result
-        result.extend(items.into_iter());
+        result.extend(items);
     }
     // pos is fully consumed above
 
diff --git a/crates/ouros/src/repl.rs b/crates/ouros/src/repl.rs
@@ -5,7 +5,7 @@
 
 use std::time::Instant;
 
-use ahash::AHashMap;
+use ahash::{AHashMap, AHashSet};
 use num_bigint::BigInt;
 
 use crate::{
@@ -181,8 +181,6 @@ pub struct ReplSession {
     name_map: AHashMap<String, NamespaceId>,
     /// Current size of the global namespace.
     namespace_size: usize,
-    /// Number of external function slots at the start of the namespace.
-    external_function_count: usize,
     /// Script name used in parse/runtime error reporting.
     script_name: String,
     /// VM snapshot waiting to be resumed after an interactive yield.
@@ -205,6 +203,8 @@ pub struct ReplSession {
     /// `ResolveFutures` is returned to the host, and stored in
     /// `PendingFuturesState` for incremental resolution.
     future_metadata: AHashMap<u32, PendingFutureInfo>,
+    /// O(1) membership set mirroring `external_functions` for name checks.
+    external_function_set: AHashSet<String>,
 }
 
 impl ReplSession {
@@ -238,6 +238,7 @@ impl ReplSession {
         }
 
         let namespace_size = namespace_values.len();
+        let external_function_set: AHashSet<String> = external_functions.iter().cloned().collect();
 
         Self {
             interner: InternerBuilder::new(""),
@@ -247,13 +248,13 @@ impl ReplSession {
             namespaces: Namespaces::new(namespace_values),
             name_map,
             namespace_size,
-            external_function_count: external_function_ids.len(),
             script_name: script_name.to_string(),
             pending_snapshot: None,
             pending_resume_state: None,
             pending_futures_state: None,
             capabilities: None,
             future_metadata: AHashMap::new(),
+            external_function_set,
         }
     }
 
@@ -268,6 +269,64 @@ impl ReplSession {
         self.capabilities = capabilities;
     }
 
+    /// Returns `true` if `name` is a registered external function.
+    fn is_external_function_name(&self, name: &str) -> bool {
+        self.external_function_set.contains(name)
+    }
+
+    /// Returns the list of registered external function names.
+    #[must_use]
+    pub fn external_function_names(&self) -> &[String] {
+        &self.external_functions
+    }
+
+    /// Registers additional external functions on an existing session without
+    /// clearing state.
+    ///
+    /// Functions that are already registered as external functions are silently
+    /// skipped. Names that collide with existing user variables are also skipped
+    /// to avoid destroying session state.
+    ///
+    /// New functions are added at the end of the namespace and are immediately
+    /// callable from subsequent `execute()` calls.
+    ///
+    /// Returns the names that were skipped due to collision with user variables.
+    pub fn register_external_functions(&mut self, new_functions: Vec<String>) -> Result<Vec<String>, ReplError> {
+        self.ensure_not_waiting_for_resume()?;
+        let mut collisions = Vec::new();
+        for function_name in new_functions {
+            if self.external_function_set.contains(&function_name) {
+                continue;
+            }
+
+            // Check if a name_map entry exists.
+            if let Some(&existing_slot) = self.name_map.get(&function_name) {
+                let value = self.namespaces.get(GLOBAL_NS_IDX).get(existing_slot);
+                if !matches!(value, Value::Undefined) {
+                    // Live user variable -- reject to preserve state.
+                    collisions.push(function_name);
+                    continue;
+                }
+                // Tombstoned slot (Value::Undefined) -- reuse it.
+                let ext_func_id = ExtFunctionId::new(self.external_functions.len());
+                self.external_functions.push(function_name.clone());
+                self.external_function_set.insert(function_name);
+                *self.namespaces.get_mut(GLOBAL_NS_IDX).get_mut(existing_slot) = Value::ExtFunction(ext_func_id);
+            } else {
+                let ext_func_id = ExtFunctionId::new(self.external_functions.len());
+                self.external_functions.push(function_name.clone());
+                self.external_function_set.insert(function_name.clone());
+
+                let slot = NamespaceId::new(self.namespace_size);
+                self.namespace_size += 1;
+                self.namespaces.grow_global(self.namespace_size);
+                self.name_map.insert(function_name, slot);
+                *self.namespaces.get_mut(GLOBAL_NS_IDX).get_mut(slot) = Value::ExtFunction(ext_func_id);
+            }
+        }
+        Ok(collisions)
+    }
+
     /// Returns the current capability set, if any.
     #[must_use]
     pub fn capabilities(&self) -> Option<&CapabilitySet> {
@@ -303,13 +362,13 @@ impl ReplSession {
             namespaces: self.namespaces.deep_clone(),
             name_map: self.name_map.clone(),
             namespace_size: self.namespace_size,
-            external_function_count: self.external_function_count,
             script_name: self.script_name.clone(),
             pending_snapshot: None,
             pending_resume_state: None,
             pending_futures_state: None,
             capabilities: self.capabilities.clone(),
             future_metadata: AHashMap::new(),
+            external_function_set: self.external_function_set.clone(),
         }
     }
 
@@ -346,7 +405,7 @@ impl ReplSession {
             namespaces_bytes,
             name_map: self.name_map.iter().map(|(k, v)| (k.clone(), *v)).collect(),
             namespace_size: self.namespace_size,
-            external_function_count: self.external_function_count,
+            external_function_count: self.external_functions.len(),
             script_name: self.script_name.clone(),
         };
 
@@ -383,6 +442,7 @@ impl ReplSession {
         );
 
         let name_map: AHashMap<String, NamespaceId> = snapshot.name_map.into_iter().collect();
+        let external_function_set: AHashSet<String> = snapshot.external_functions.iter().cloned().collect();
 
         Ok(Self {
             interner,
@@ -392,13 +452,13 @@ impl ReplSession {
             namespaces,
             name_map,
             namespace_size: snapshot.namespace_size,
-            external_function_count: snapshot.external_function_count,
             script_name: snapshot.script_name,
             pending_snapshot: None,
             pending_resume_state: None,
             pending_futures_state: None,
             capabilities: None,
             future_metadata: AHashMap::new(),
+            external_function_set,
         })
     }
 
@@ -671,7 +731,7 @@ impl ReplSession {
         let mut vars = Vec::new();
 
         for (name, &slot) in &self.name_map {
-            if slot.index() < self.external_function_count {
+            if self.is_external_function_name(name) {
                 continue;
             }
             let value = global.get(slot);
@@ -691,7 +751,7 @@ impl ReplSession {
     #[must_use]
     pub fn get_variable(&self, name: &str) -> Option<Object> {
         let &slot = self.name_map.get(name)?;
-        if slot.index() < self.external_function_count {
+        if self.is_external_function_name(name) {
             return None;
         }
 
@@ -719,7 +779,7 @@ impl ReplSession {
 
         // First check if the variable exists
         let &slot = self.name_map.get(name)?;
-        if slot.index() < self.external_function_count {
+        if self.is_external_function_name(name) {
             return None;
         }
 
@@ -791,7 +851,7 @@ impl ReplSession {
         let new_value = value.to_value(&mut self.heap, &interns)?;
 
         if let Some(&existing_slot) = self.name_map.get(name) {
-            if existing_slot.index() < self.external_function_count {
+            if self.is_external_function_name(name) {
                 new_value.drop_with_heap(&mut self.heap);
                 return Err(InvalidInputError::invalid_type("cannot overwrite external function"));
             }
@@ -834,7 +894,7 @@ impl ReplSession {
             return Ok(false);
         };
 
-        if slot.index() < self.external_function_count {
+        if self.is_external_function_name(name) {
             return Err(InvalidInputError::invalid_type("cannot delete external function"));
         }
 
diff --git a/crates/ouros/src/session_manager.rs b/crates/ouros/src/session_manager.rs
@@ -951,6 +951,39 @@ impl SessionManager {
         entry.history.clear();
         Ok(())
     }
+
+    /// Registers additional external functions on an existing session without
+    /// clearing state.
+    ///
+    /// Functions already registered are silently skipped. Names that collide
+    /// with existing user variables are skipped (returned in the result vec).
+    /// New functions are appended and become immediately callable. Existing
+    /// variables and execution history are preserved.
+    ///
+    /// Returns the names that were skipped due to collision with user variables.
+    ///
+    /// # Errors
+    ///
+    /// Returns `SessionError::NotFound` if the session does not exist, or
+    /// `SessionError::InvalidState` if the session has a pending external call.
+    pub fn register_external_functions(
+        &mut self,
+        session_id: Option<&str>,
+        external_functions: Vec<String>,
+    ) -> Result<Vec<String>, SessionError> {
+        let sid = resolve_session_id(session_id);
+        let entry = self.get_session_mut(sid)?;
+
+        if entry.pending_call_id.is_some() {
+            return Err(SessionError::InvalidState(
+                "cannot register external functions while a call is pending".to_owned(),
+            ));
+        }
+
+        let collisions = entry.session.register_external_functions(external_functions)?;
+        entry.external_functions = entry.session.external_function_names().to_vec();
+        Ok(collisions)
+    }
 }
 
 // =============================================================================
diff --git a/crates/ouros/src/types/weakref.rs b/crates/ouros/src/types/weakref.rs
diff --git a/crates/ouros/src/value.rs b/crates/ouros/src/value.rs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "ouros",`
`3`		`- "version": "0.0.4",`
	`3`	`+ "version": "0.0.6",`
`4`	`4`	`"type": "module",`
`5`	`5`	`"description": "Sandboxed Python interpreter for JavaScript/TypeScript",`
`6`	`6`	`"main": "wrapper.js",`
Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ fn itertools_chain(heap: &mut Heap<impl ResourceTracker>, interns: &Interns, arg`
`350`	`350`	`iter.drop_with_heap(heap);`
`351`	`351`
`352`	`352`	`// items contains owned values - transfer ownership to result`
`353`		`- result.extend(items.into_iter());`
	`353`	`+ result.extend(items);`
`354`	`354`	`}`
`355`	`355`	`// pos is fully consumed above`
`356`	`356`