Add built-in NumPy support

README.md

@@ -30,6 +30,7 @@ What Monty **can** do:
 - Completely block access to the host environment: filesystem, env variables and network access are all implemented via external function calls the developer can control
 - Call functions on the host - only functions you give it access to
 - Run typechecking - monty supports full modern python type hints and comes with [ty](https://docs.astral.sh/ty/) included in a single binary to run typechecking
+- Run many `import numpy as np` numeric array workloads with built-in NumPy support for arrays, dtypes, broadcasting, ufunc-style math, reductions, indexing, shape manipulation and common numeric helpers
 - Be snapshotted to bytes at external function calls, meaning you can store the interpreter state in a file or database, and resume later
 - Startup extremely fast (<1μs to go from code to execution result), and has runtime performance that is similar to CPython (generally between 5x faster and 5x slower)
 - Be called from Rust, Python, or Javascript - because Monty has no dependencies on cpython, you can use it anywhere you can run Rust
@@ -41,7 +42,7 @@ What Monty **can** do:
 What Monty **cannot** do:
 
 - Use the rest of the standard library
-- Use third party libraries (like Pydantic), support for external python library is not a goal
+- Load arbitrary third party libraries (like Pydantic). NumPy support is built into Monty; it is not general package import support
 - define classes (support should come soon)
 - use match statements (again, support should come soon)
 
@@ -66,6 +67,30 @@ In very simple terms, the idea of all the above is that LLMs can work faster, ch
 
 Monty can be called from Python, JavaScript/TypeScript or Rust.
 
+### Built-in NumPy support
+
+Monty includes a built-in `numpy` module for safe numeric array workloads. This is implemented inside the sandbox, so user code can write ordinary `import numpy as np` snippets without loading CPython's C-backed NumPy package or gaining host access.
+
+```python
+import pydantic_monty
+
+code = """
+import numpy as np
+
+scores = np.array([[1, 2, 3], [4, 5, 6]])
+weights = np.array([10, 20, 30])
+weighted = scores * weights
+
+(weighted.tolist(), weighted.sum(), scores.mean(), str(scores.astype('float').dtype))
+"""
+
+m = pydantic_monty.Monty(code)
+print(m.run())
+#> ([[10, 40, 90], [40, 100, 180]], 460, 3.5, 'float64')
+```
+
+The supported NumPy surface is the pure, sandbox-safe numeric core: `ndarray`, supported numeric dtypes, broadcasting, ufunc-style math and predicates, reductions, indexing, shape helpers, sorting/selection helpers, formatting helpers, and common construction/manipulation routines. Monty intentionally does not expose host-boundary or external-memory APIs such as file loaders/savers, `memmap`, DLPack, `ctypeslib`, or include-path discovery, and it does not aim to implement full submodule families such as `linalg`, `fft`, `random`, `ma`, `testing`, or `typing`.
+
 ### Python
 
 To install:

crates/monty-datatest/src/main.rs

@@ -86,6 +86,9 @@ struct TestConfig {
     /// When true, wrap code in async context for CPython execution.
     /// Used for tests with top-level await which Monty supports but CPython doesn't.
     async_mode: bool,
+    /// When true, skip running this test on CPython.
+    /// Used for tests that require modules not available in the CPython test harness.
+    skip_cpython: bool,
     /// When true, create a temporary directory with a known structure and mount it.
     /// For Monty: mounted at `/mnt` with `OverlayMemory` mode.
     /// For CPython: passed as real path. `root` variable injected into both.
@@ -172,14 +175,18 @@ fn parse_fixture(content: &str) -> (String, Expectation, TestConfig) {
         .map(|line| line.trim_start_matches('#').trim())
         .collect::<Vec<_>>();
 
-    let mount_fs = comment_lines.iter().any(|line| line.starts_with("mount-fs"));
+    let has_marker = |marker| {
+        comment_lines
+            .iter()
+            .any(|line| line.split_whitespace().next() == Some(marker))
+    };
+    let mount_fs = has_marker("mount-fs");
     let mut config = TestConfig {
-        iter_mode: comment_lines.iter().any(|line| line.starts_with("call-external")) || mount_fs,
-        async_mode: comment_lines.iter().any(|line| line.starts_with("run-async")),
+        iter_mode: has_marker("call-external") || mount_fs,
+        async_mode: has_marker("run-async"),
+        skip_cpython: has_marker("skip-cpython"),
         mount_fs,
-        skip_cpython_windows: comment_lines
-            .iter()
-            .any(|line| line.starts_with("skip-cpython-windows")),
+        skip_cpython_windows: has_marker("skip-cpython-windows"),
         ..Default::default()
     };
     // Check for "xfail=" directive
@@ -2372,6 +2379,10 @@ fn run_test_cases_cpython(path: &Path) -> Result<(), Box<dyn Error>> {
         .display()
         .to_string();
 
+    if config.skip_cpython {
+        return Ok(());
+    }
+
     // Skip CPython tests that rely on POSIX path semantics when running on Windows
     if cfg!(windows) && config.skip_cpython_windows {
         return Ok(());

crates/monty-js/README.md

@@ -25,6 +25,26 @@ const m = new Monty('x + y', { inputs: ['x', 'y'] })
 const result = m.run({ inputs: { x: 10, y: 20 } }) // returns 30
 ```
 
+## Built-in NumPy Support
+
+Monty includes a built-in `numpy` module for pure numeric array workloads inside the sandbox. User code can import NumPy-style APIs without loading CPython's C-backed NumPy package or exposing host files, external memory, network access, or other host-boundary features.
+
+```ts
+const m = new Monty(`
+import numpy as np
+
+scores = np.array([[1, 2, 3], [4, 5, 6]])
+weights = np.array([10, 20, 30])
+weighted = scores * weights
+
+weighted.tolist()
+`)
+
+const result = m.run() // returns [[10, 40, 90], [40, 100, 180]]
+```
+
+Supported NumPy behavior focuses on Monty's sandbox-safe numeric core: `ndarray`, supported numeric dtypes, broadcasting, ufunc-style math and predicates, reductions, indexing, shape helpers, sorting/selection helpers, formatting helpers, and common construction/manipulation routines. Host-boundary APIs, external-memory APIs, object/string/complex/datetime arrays, and full submodule families such as `linalg`, `fft`, `random`, `ma`, `testing`, and `typing` are intentionally outside this built-in subset.
+
 ## External Functions
 
 For synchronous external functions, pass them directly to `run()`:

crates/monty-python/README.md

@@ -36,6 +36,30 @@ print(m.run(inputs={'x': 10, 'y': 5}))
 #> 50
 ```
 
+### Built-in NumPy Support
+
+Monty includes a built-in `numpy` module for pure numeric array workloads inside the sandbox. This lets user code import NumPy-style APIs without loading CPython's C-backed NumPy package or exposing host files, external memory, network access, or other host-boundary features.
+
+```python
+import pydantic_monty
+
+code = """
+import numpy as np
+
+scores = np.array([[1, 2, 3], [4, 5, 6]])
+weights = np.array([10, 20, 30])
+weighted = scores * weights
+
+(weighted.tolist(), weighted.sum(), scores.mean(), str(scores.astype('float').dtype))
+"""
+
+m = pydantic_monty.Monty(code)
+print(m.run())
+#> ([[10, 40, 90], [40, 100, 180]], 460, 3.5, 'float64')
+```
+
+Supported NumPy behavior focuses on Monty's sandbox-safe numeric core: `ndarray`, supported numeric dtypes, broadcasting, ufunc-style math and predicates, reductions, indexing, shape helpers, sorting/selection helpers, formatting helpers, and common construction/manipulation routines. Host-boundary APIs, external-memory APIs, object/string/complex/datetime arrays, and full submodule families such as `linalg`, `fft`, `random`, `ma`, `testing`, and `typing` are intentionally outside this built-in subset.
+
 ### Resource Limits
 
 ```python