test: adopt Scriptorium (Quill + Nib) for the cross-target suite (#35)

* test: adopt Scriptorium (Quill + Nib) for the cross-target suite

Replace the hand-rolled runner in test/Program.fs with Scriptorium.Quill and the
shouldEqual/shouldBeTrue helpers with Scriptorium.Nib, laid out the way Fable.Giraffe
does it: one shared suite plus a small runner project per target.

    test/shared/    Helpers.fs, ActorTests.fs, SupervisionTests.fs, BuilderTests.fs
    test/dotnet/    dotnet run
    test/python/    Fable -> Python
    test/js/        Fable -> JS/Node
    test/beam/      Fable -> Erlang

All 28 tests were ported, not rewritten — only the assertions and the runner changed.
Quill speaks Async and the library speaks ActorOp, so Helpers.toAsync bridges the two:
the identity on Python/JS/.NET (where ActorOp = Async) and a Run of the CPS chain on
BEAM (where Async is erased to synchronous callbacks anyway).

Upgrade Fable 5.11 -> 5.13: 5.11 emits Fable package sub-namespaces into nested
Sinks/src/ directories that rebar3 never compiles, leaving
scriptorium_parchment_sinks_universal undefined and crashing the BEAM run after the
tests had passed. 5.13 emits it flat. Verified the src BEAM build and all three
timeflies examples still build.

Add a JS runner, and make test-native a real behavioral run rather than a compile
smoke test — the non-BEAM Actor is MailboxProcessor-based, so the suite genuinely
exercises it on .NET.

The BEAM run is now self-contained in build/tests-beam (Fable pulls the Fable.Actor
sources into the same outDir and generates the rebar.config), so it no longer shares
apps/ with the library build, where two competing main.erl modules had to coexist.

Delete test/test_runner.erl — dead code listing AsyncRx-era modules that no longer
exist.

28/28 on .NET, Python, JS and BEAM.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* refactor: collapse the per-target test projects into one

The four runner projects were ceremony copied from Fable.Giraffe without re-deriving
whether its cause applies here. It does not: Giraffe has a src project per target that
each test project must reference (plus BEAM-only deps like Fable.Beam.Cowboy and a rebar
cowboy dep), whereas Fable.Actor has one library project with #if FABLE_COMPILER_BEAM
inside. Fable.Beam arrives transitively through the project reference, so even the BEAM
runner needed no package of its own.

The four Main.fs files were byte-identical apart from comments, and the four fsproj files
differed only by that one redundant Fable.Beam reference.

One project compiles to all four targets from a shared obj/, back to back, with no
--noCache — 28/28 on .NET, Python, JS and BEAM. The per-target runner comments are
consolidated into test/Main.fs, and test/shared/ is gone: it only meant something when
there was a non-shared counterpart.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* chore: fix the dev=true Fable path in the justfile

fable_repo pointed at ../fable/beam-improvements-17 and ../fable/main. The branch name
is long dead, and the parent path is wrong too — ../fable does not exist on a
case-sensitive filesystem, so every dev=true recipe was broken, not just the BEAM one.

Point it at ../Fable/src/Fable.Cli, the same convention Fable.Giraffe uses, and let
whatever branch that checkout has out be the one used. That collapses fable/fable_beam
back into a single variable: the split only encoded "the BEAM backend lives on its own
branch", which stopped being true once every backend landed in one repo.

Also route build-timeflies-js through {{fable}} — it hardcoded `dotnet fable`, so
dev=true silently skipped it.

Verified dev=true now expands to an existing Fable.Cli.fsproj, and the default
dev=false path still runs 28/28 on all four targets.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: dbrattli

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "fable": {
-      "version": "5.11.0",
+      "version": "5.13.0",
       "commands": [
         "fable"
       ],

.github/workflows/build-and-test.yml

@@ -29,6 +29,11 @@ jobs:
         with:
           python-version: '3.12'
 
+      - name: Setup Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: '20'
+
       - name: Install uv
         uses: astral-sh/setup-uv@v6
 
@@ -41,20 +46,21 @@ jobs:
       - name: Build library
         run: dotnet build src/Fable.Actor
 
-      - name: Build tests
-        run: dotnet build test
-
+      # The shared suite (test/shared) runs on .NET, Python, JS and BEAM
       - name: Run .NET tests
-        run: dotnet run --project test
-
-      - name: Compile tests to Python
-        run: dotnet fable test --lang python --outDir build/tests --exclude Fable.Core --noCache
+        run: just test-native
 
       - name: Run Python tests
-        run: cd build/tests && uv run --project ../.. python program.py
+        run: just test-python
+
+      - name: Run JS tests
+        run: just test-js
 
-      - name: Build BEAM and run tests
+      - name: Run BEAM tests
         run: just test-beam
 
+      - name: Build BEAM library
+        run: just build
+
       - name: Pack NuGet
         run: just pack

CLAUDE.md

@@ -9,10 +9,46 @@ Fable.Actor is a cross-platform actor library written in F# and compiled via [Fa
 ## Build Commands
 
 ```sh
-dotnet build src/Fable.Actor    # Type-check
-dotnet fantomas src -r           # Format
+just check                       # Type-check library + test projects
+just build                       # F# -> Erlang, then rebar3 compile
+just format                      # dotnet fantomas src test
+just test                        # Shared suite on .NET + Python + JS + BEAM
+just test-native                 # .NET only (fastest feedback loop)
+just test-beam                   # BEAM only
 ```
 
+## Tests
+
+One suite, one project (`test/Fable.Actor.Tests.fsproj`), compiled to each target:
+
+```
+test/Helpers.fs  ActorTests.fs  SupervisionTests.fs  BuilderTests.fs  Main.fs
+```
+
+Assertions come from [Scriptorium](https://github.com/fable-hub/Scriptorium) — Nib for
+`assertThat x (isEqualTo y)`, Quill for the runner (`runTests [ ... ]`).
+
+Do **not** split this into a project per target. Fable.Giraffe does, because it has a src project
+per target that each test project must reference; Fable.Actor has one library project with
+`#if FABLE_COMPILER_BEAM` inside, and `Fable.Beam` arrives transitively through the project
+reference. One project compiles cleanly to all four targets from a shared `obj/`, no `--noCache`
+needed. Split only if a target ever needs its own package or rebar dependency.
+
+Notes:
+
+- **Quill speaks `Async`, the library speaks `ActorOp`.** `Helpers.toAsync` bridges them: the
+  identity on Python/JS/.NET (where `ActorOp = Async`), and on BEAM a `Run` of the CPS chain
+  (where `Async` is erased to synchronous callbacks anyway). Tests read
+  `testAsync("name", fun _ -> toAsync (actor { ... }))`.
+- **`reporter`** (in `Helpers.fs`) is how a test observes state that crosses a process boundary:
+  on BEAM a `let mutable` captured by a spawned actor is a copy, so the value has to be published
+  with `Actor.cast` and read back with `Actor.call`.
+- **BEAM prints `Error in process <0.x.0> with exit value:` reports.** That is the VM logging the
+  children the supervision tests deliberately crash — expected, not a failure. The exit code and
+  Quill's summary line are what matter.
+- The BEAM run is self-contained: Fable compiles the suite *and* the `Fable.Actor` sources it
+  references into `build/tests-beam`, and generates the `rebar.config` for it.
+
 ## Architecture
 
 One F# project: `src/Fable.Actor/`
@@ -48,6 +84,9 @@ Each target provides a native `fable_actor_platform` module implementing `IActor
 ## Dependencies
 
 - .NET SDK 10+
-- Fable 5.11 (local tool, see `.config/dotnet-tools.json`)
-- Fable.Core 5.0.0
+- Fable 5.13 (local tool, see `.config/dotnet-tools.json`) — 5.11 emits Fable package
+  sub-namespaces into nested `Sinks/src/` directories that rebar3 never compiles, which breaks
+  Scriptorium.Parchment on BEAM
+- Fable.Core 5.0.0 (library) / 5.2.0 (test projects, required by Scriptorium)
 - fable-library 5.11+ (Python target)
+- Scriptorium.Quill 0.5.1 + Scriptorium.Nib 0.4.1 (test projects only)

README.md

@@ -18,11 +18,16 @@ just format   # Format source with Fantomas
 
 ## Test
 
+One behavioral suite in `test/` runs on every target — the same project, compiled by Fable to each
+language. Tests are written with [Scriptorium](https://github.com/fable-hub/Scriptorium) — Quill for
+the runner, Nib for assertions.
+
 ```sh
-just test-native   # Run .NET tests
+just test-native   # Run on .NET (MailboxProcessor implementation)
 just test-python   # Compile to Python via Fable, then run
-just test-beam     # Compile to Erlang via Fable, then run
-just test          # Run .NET + Python tests
+just test-js       # Compile to JavaScript via Fable, then run under Node
+just test-beam     # Compile to Erlang via Fable, then run on the BEAM VM
+just test          # All four
 ```
 
 ## Quick Start

justfile

@@ -1,11 +1,11 @@
 # Fable.Actor development tasks
 
-# Development mode: use local Fable repo instead of dotnet tool
+# Development mode: compile with a local Fable checkout instead of the pinned dotnet tool.
+# Whatever branch that checkout has out is what gets used — every backend lives in one repo.
 # Usage: just dev=true test-beam
 dev := "false"
-fable_repo := justfile_directory() / "../fable"
-fable := if dev == "true" { "dotnet run --project " + fable_repo / "beam-improvements-17/src/Fable.Cli" + " --" } else { "dotnet fable" }
-fable_python := if dev == "true" { "dotnet run --project " + fable_repo / "main/src/Fable.Cli" + " --" } else { "dotnet fable" }
+fable_repo := justfile_directory() / "../Fable"
+fable := if dev == "true" { "dotnet run --project " + fable_repo / "src/Fable.Cli" + " --" } else { "dotnet fable" }
 
 src_path := "src/Fable.Actor"
 build_path := "build"
@@ -30,10 +30,11 @@ build: clean
 # Build F# projects only (type check)
 check:
     dotnet build src/Fable.Actor
+    dotnet build {{test_path}}
 
 # Format source files
 format:
-    dotnet fantomas src
+    dotnet fantomas src {{test_path}}
 
 # Setup tooling
 restore:
@@ -65,32 +66,37 @@ shipit *args:
 
 # --- Tests ---
 
-# Run all tests (.NET + Python + BEAM)
-test: test-native test-python test-beam
+# One suite in test/, compiled to each target from the same project. Assertions come from
+# Scriptorium.Nib, the runner from Scriptorium.Quill.
+
+# Run the behavioral suite on every target (.NET + Python + JS + BEAM)
+test: test-native test-python test-js test-beam
 
-# Run .NET tests only
+# .NET target: a real behavioral run — the non-BEAM Actor is MailboxProcessor-based
 test-native:
-    dotnet build {{test_path}}
-    @echo "Running .NET tests..."
     dotnet run --project {{test_path}}
 
-# Run Python tests: compile F# → Python via Fable, then run
+# Python target: compile the suite to Python and run the explicit runner
 test-python:
-    rm -rf {{build_path}}/tests
-    {{fable_python}} {{test_path}} --lang python --outDir {{build_path}}/tests --exclude Fable.Core --noCache
-    @echo "Running Python tests..."
-    cd {{build_path}}/tests && uv run --project ../.. python program.py
-
-# Run BEAM tests: compile F# → Erlang via Fable, then run
-test-beam: build
-    {{fable}} {{test_path}} --exclude Fable.Core --lang beam --outDir apps/test --noCache
-    cd {{justfile_directory()}} && rebar3 compile
-    @echo "Running BEAM tests..."
-    cd {{justfile_directory()}} && erl \
-        -pa _build/default/lib/*/ebin \
-        -noshell \
-        -eval "main:main([])" \
-        -s init stop
+    rm -rf {{build_path}}/tests-py
+    {{fable}} {{test_path}} --exclude Fable.Core --lang python --outDir {{build_path}}/tests-py
+    uv run python {{build_path}}/tests-py/main.py
+
+# JS target: compile the suite to JS and run it under Node
+test-js:
+    rm -rf {{build_path}}/tests-js
+    {{fable}} {{test_path}} --exclude Fable.Core --lang javascript --outDir {{build_path}}/tests-js
+    echo '{"type":"module"}' > {{build_path}}/tests-js/package.json
+    node {{build_path}}/tests-js/Main.js
+
+# BEAM target: compile the suite to Erlang, build with rebar3, run on the BEAM VM.
+# Fable pulls the Fable.Actor sources into the same outDir, so this app is self-contained
+# and the generated rebar.config needs no edits. Quill calls halt/1 with the exit code.
+test-beam:
+    rm -rf {{build_path}}/tests-beam
+    {{fable}} {{test_path}} --exclude Fable.Core --lang beam --outDir {{build_path}}/tests-beam
+    cd {{build_path}}/tests-beam && rebar3 compile
+    cd {{build_path}}/tests-beam && erl -noshell -pa _build/default/lib/*/ebin -eval 'main:main([])'
 
 # --- Timeflies example ---
 
@@ -121,7 +127,7 @@ timeflies_py_out := timeflies_py_path / "output"
 # Build timeflies-python: F# → Python via Fable
 build-timeflies-python:
     rm -rf {{timeflies_py_out}}
-    {{fable_python}} {{timeflies_py_src}} --lang python --outDir {{timeflies_py_out}} --exclude Fable.Core --noCache
+    {{fable}} {{timeflies_py_src}} --lang python --outDir {{timeflies_py_out}} --exclude Fable.Core --noCache
     touch {{timeflies_py_out}}/src/__init__.py
     touch {{timeflies_py_out}}/src/Fable_Actor/__init__.py
 
@@ -137,7 +143,7 @@ timeflies_js_src := timeflies_js_path / "src"
 # Build timeflies-js: F# → JavaScript via Fable
 build-timeflies-js:
     cd {{timeflies_js_path}} && npm install
-    cd {{timeflies_js_path}} && dotnet fable src --noCache
+    cd {{timeflies_js_path}} && {{fable}} src --noCache
 
 # Run timeflies-js demo on http://localhost:3000
 run-timeflies-js: build-timeflies-js

rebar.config

@@ -1,3 +1,3 @@
 {erl_opts, [no_debug_info, nowarn_unused_result]}.
 
-{project_app_dirs, ["apps/fable_actor", "apps/fable_actor/fable_modules/*", "apps/test"]}.
+{project_app_dirs, ["apps/fable_actor", "apps/fable_actor/fable_modules/*"]}.