fix(ci): Skip wasm build for pure-Python test stdpkg.

Author: dylan-sutton-chavez

.github/workflows/README.md

@@ -14,7 +14,7 @@ check -> wasm -> runtime -> demo
 | `_demo.yml` | Hashes `compiler_lib.wasm` into `version.json` (cache-busting) and deploys `demo/` to Cloudflare Pages |
 | `cli.yml` | Standalone (not part of the pipeline above): builds and tests `cli/`; on `main` pushes also publishes the release binary + `cli/setup/` scripts (`install.sh`, `uninstall.sh`) to GitHub Pages |
 | `host.yml` | Standalone: deno-lints and tests each host capability (`dom`, `network`, `storage`, `time`) in headless Chromium; on `main` pushes also deploys their ESM sources to Cloudflare Pages (`edge-python-host`) |
-| `std.yml` | Standalone: clippy + build + optimize + test each stdpkg wasm (`json`, `re`, `math`); on `main` pushes also deploys the per-package `.wasm` to Cloudflare Pages (`edge-python-std`) |
+| `std.yml` | Standalone: clippy + build + optimize + test each stdpkg (`json`, `re`, `math` as wasm; `test` is pure Edge Python, so its steps skip the wasm build and only run the corpus); on `main` pushes also deploys the per-package `.wasm` to Cloudflare Pages (`edge-python-std`) |
 
 ## Cloudflare Pages
 

.github/workflows/std.yml

@@ -47,10 +47,11 @@ jobs:
 
       # Lint only the cdylib; --all-targets clashes with its panic handler.
       - name: Clippy src/
+        if: matrix.package != 'test'
         working-directory: std/${{ matrix.package }}
         run: cargo clippy --release --target wasm32-unknown-unknown -- -D warnings
 
-  # Build, optimize, and test each package's wasm; uploads the artifact for the deploy step.
+  # Build, optimize, and test each package; uploads the wasm artifact for the deploy step.
   wasm:
     name: WASM (${{ matrix.package }})
     needs: lint
@@ -100,12 +101,15 @@ jobs:
 
       # apt ships an old binaryen, so fetch the upstream release.
       - name: Install wasm-opt
+        if: matrix.package != 'test'
         run: |
           curl -sSL "https://github.com/WebAssembly/binaryen/releases/download/version_${BINARYEN_VERSION}/binaryen-version_${BINARYEN_VERSION}-x86_64-linux.tar.gz" \
             | tar -xz --strip-components=2 -C /usr/local/bin "binaryen-version_${BINARYEN_VERSION}/bin/wasm-opt"
           wasm-opt --version
 
+      # `test` is pure Edge Python (src/entry.py): no crate to compile, so skip the wasm build/optimize/upload and let the corpus run below.
       - name: Build
+        if: matrix.package != 'test'
         working-directory: std/${{ matrix.package }}
         run: |
           RUSTFLAGS="-Z location-detail=none -Z fmt-debug=none -Z unstable-options -C panic=immediate-abort" \
@@ -115,10 +119,12 @@ jobs:
             -Z build-std=std,panic_abort
 
       - name: Size (unoptimized)
+        if: matrix.package != 'test'
         run: ls -lh "$WASM"
 
       # Two passes: -Oz with traps-never-happen, then reflatten for a fresh CFG.
       - name: Optimize
+        if: matrix.package != 'test'
         run: |
           wasm-opt -Oz --converge \
             --generate-global-effects \
@@ -138,16 +144,18 @@ jobs:
           rm /tmp/wasm_stage1.wasm
 
       - name: Size (optimized)
+        if: matrix.package != 'test'
         run: ls -lh "$WASM"
 
-      # STDPKG narrows Deno's test discovery to this package's corpus.
+      # STDPKG narrows Deno's test discovery to this package's corpus. The driver routes .py packages to src/entry.py, native ones to the built wasm.
       - name: Test
         working-directory: std
         env:
           STDPKG: ${{ matrix.package }}
         run: deno test --allow-all tests/
 
       - uses: actions/upload-artifact@v6
+        if: matrix.package != 'test'
         with:
           name: wasm-${{ matrix.package }}
           path: ${{ env.WASM }}

docs/reference/packages.md

@@ -63,6 +63,33 @@ print(factorial(5)) # 120
 
 Integers are bounded by the VM's `i128`, so `factorial`, `comb`, `perm`, and `lcm` raise `ValueError` past that range, and there is no `complex` / `cmath`. Pre-built `.wasm` is served from `https://std.edgepython.com/math.wasm`. Full API: [`std/math/README.md`](https://github.com/dylan-sutton-chavez/edge-python/tree/main/std/math).
 
+### `test`
+
+A tiny unit-test harness written in pure Edge Python, not a Rust `.wasm` module: fixtures, test registration, exception assertions, and a runner that reports pass/fail and sets the exit code. It leans only on language built-ins (`assert`, `issubclass`, `SystemExit`), so it needs no host capability and runs wherever the VM runs.
+
+```python
+from test import fixture, test, raises, run
+
+@fixture
+def user():
+    return {"name": "Ana"}
+
+@test("user has a name", "user")
+def test_name(user):
+    assert user["name"] == "Ana"
+
+@test("division by zero raises")
+def test_div():
+    with raises(ZeroDivisionError):
+        1 / 0
+
+run() # prints PASS/FAIL lines and a summary, then raises SystemExit(0 if all passed, else 1)
+```
+
+`@fixture` registers a `def` under its name and injects it by keyword into the tests that ask for it; `@test(description, *uses)` registers a test plus the fixtures it pulls; `raises(ExcType)` is a context manager asserting the block raises `ExcType` (a subclass, or any type in a tuple); `run()` executes every registered test, prints `PASS` / `FAIL` / `ERROR` and a summary, then raises `SystemExit(1 if any failed, else 0)` so a host can read the result as a process exit code.
+
+Unlike the other standard packages, `test` ships as **pure Edge Python source** (`src/entry.py`), not a compiled `.wasm`, so there is no `cargo` build and nothing served from `std.edgepython.com`; the browser runtime resolves it by default and imports the `.py` directly (see [Defaults](#defaults)). Full API: [`std/test/README.md`](https://github.com/dylan-sutton-chavez/edge-python/tree/main/std/test).
+
 ## Host libraries
 
 Plain-JS capabilities that run on the browser's main thread, registered declaratively via the `host` field of [`packages.json`](/reference/imports#packages-json) (with the `<edge-python>` element), programmatically via `createWorker({ hostModules })`, or resolved by default with no config at all (see [Defaults](#defaults)). No `.wasm`, no Rust, no build step. Each call defers to the main thread over `postMessage` (around 0.1 to 0.4 ms); Python sees a synchronous call. The ESM loads lazily, the first time a run imports it.
@@ -143,7 +170,7 @@ One manifest drives both directions: `imports` for worker-side `.py` / `.wasm` m
 
 ### Defaults
 
-The browser runtime ships a built-in base manifest, so the official packages resolve by bare name with **no `packages.json` at all**: the std `.wasm` packages (`json`, `re`, `math`) and the host libraries (`dom`, `network`, `storage`, `time`). Three rules:
+The browser runtime ships a built-in base manifest, so the official packages resolve by bare name with **no `packages.json` at all**: the std packages (`json`, `re`, `math`, and the pure-Python `test`) and the host libraries (`dom`, `network`, `storage`, `time`). Three rules:
 
 - **Lazy.** A default is fetched only when a run actually imports it. Unused defaults never hit the network.
 - **Overridable.** Your `packages.json` (or `imports` / `hostModules`) wins for the same name, so you can pin a specific version or URL.

std/README.md

@@ -1,15 +1,15 @@
 # Edge Python Standard Packages
 
-Official `.wasm` standard-library packages for [Edge Python](https://edgepython.com). Each capability is a Rust crate compiled to `wasm32-unknown-unknown` against the [wasm-pdk](https://github.com/dylan-sutton-chavez/edge-python/tree/main/wasm-pdk) ABI. Hosts load the resulting `.wasm` over the standard plugin contract, no custom embedder, no Rust on the consumer side.
+Official standard-library packages for [Edge Python](https://edgepython.com). Most are a Rust crate compiled to `wasm32-unknown-unknown` against the [wasm-pdk](https://github.com/dylan-sutton-chavez/edge-python/tree/main/wasm-pdk) ABI; hosts load the resulting `.wasm` over the standard plugin contract, no custom embedder, no Rust on the consumer side. A package can also ship as pure Edge Python source (`src/entry.py`), imported as a code module with no `cargo` build (e.g. `test`).
 
 ## Layout
 
 ```
 tests/, agnostic Deno + Playwright runner driving the <edge-python> tag
-<name>/, one folder per stdpkg crate, with src/, README.md, and <name>.json corpus
+<name>/, one folder per stdpkg, with src/, README.md, and <name>.json corpus
 ```
 
-The folder name IS the package name IS the wasm artifact name (e.g. `json/` -> `json/target/wasm32-unknown-unknown/release/json.wasm`). Each package's `<name>.json` sits alongside `Cargo.toml`; cases in it are automatically prefixed with `from <name> import *\n` before dispatch, so the corpus only contains the code being tested.
+The folder name IS the package name. A native package builds to `<name>/target/wasm32-unknown-unknown/release/<name>.wasm`; a pure-Python package has `src/entry.py` and no build artifact. Each package's `<name>.json` corpus sits in its folder; cases in it are automatically prefixed with `from <name> import *\n` before dispatch, so the corpus only contains the code being tested.
 
 ## Packages
 
@@ -18,13 +18,14 @@ The folder name IS the package name IS the wasm artifact name (e.g. `json/` -> `
 | `json` | JSON serialization/deserialization, see [`json/README.md`](json/README.md) |
 | `re` | Regular expressions, a subset with capture, backreferences, lookaround, and a ReDoS step budget, see [`re/README.md`](re/README.md) |
 | `math` | CPython-style math over libm, integer ops, and a packed-f64 batch fast path, see [`math/README.md`](math/README.md) |
+| `test` | Tiny unit-test harness in pure Edge Python (fixtures, `raises`, runner with exit code), see [`test/README.md`](test/README.md) |
 
 ## Build + test
 
-Each package builds independently; the agnostic runner asserts against the produced `.wasm`. From the repo root:
+Native packages build independently; the agnostic runner asserts against the produced `.wasm`, or against `src/entry.py` for a pure-Python package. From the repo root:
 
 ```bash
-# Build every package's .wasm artifact.
+# Build a native package's .wasm artifact (skip for pure-Python packages like test).
 ( cd json && cargo build --release --target wasm32-unknown-unknown )
 
 # One command, drives all corpora through the shared runner.
@@ -35,11 +36,15 @@ The runner discovers packages by walking the repo root for `<name>/<name>.json`
 
 ## Adding a new stdpkg
 
+For a native (wasm) package:
+
 1. Create `<name>/` at the repo root with `Cargo.toml` (`name = "<name>"`, `crate-type = ["cdylib"]`, `wasm-pdk` dep) and a `src/lib.rs` exporting via `#[plugin_fn]`.
 2. Drop `<name>/<name>.json` with the corpus (Edge Python source + expected `output` / `error` per case).
 3. Run `cargo build --release --target wasm32-unknown-unknown` inside the package folder.
 4. Run `deno test --allow-all tests/` from the repo root.
 
+For a pure-Python package, skip the crate: add `<name>/src/entry.py` plus `<name>/<name>.json`, then run `deno test --allow-all tests/`. The runner routes `.py` packages to their source and skips the wasm build.
+
 No edits to `tests/`.
 
 ## License