2 Commits

Author	SHA1	Message	Date
giles	03c32cda5f	fed-sx-m2: resolve Blockers #4 — kernel routes now work over real HTTP ... Substrate fix: two-line change to lib/erlang/runtime.sx that lets http-listen handler routes call gen_server:call without deadlocking. 1. er-sched-step-alive!: pass :pending-args (when set) to the initial-fun call instead of always passing an empty list. Default behavior (no field) stays (list) — drop-in safe. 2. er-bif-http-listen sx-handler: instead of er-apply-fun handler inline (which blows up on receive's er-suspend-marker because the connection thread has no scheduler step on its stack), create a real er-process with :initial-fun = handler and :pending-args = (list req-pl), then er-sched-run-all! to drain. Any receive (e.g. gen_server:call) suspends + resumes inside the SX scheduler frame the process owns. Read :exit-result for the response proplist; marshal back to SX dict. Investigation arc (see plans/fed-sx-milestone-2.md Blockers #4 + Progress log): - loops/fed-prims bf8d0bf2 diagnosed it as Erlang-substrate, not OCaml mutex (Pattern A wrong, Pattern B right but sketchy). - First Pattern B attempt failed: tried er-spawn-fun on a raw SX lambda, hit (er-fun? fv) gate. Connection-thread bisect pinpointed the exact line. - Real fix: use the existing er-fun (user's handler) directly, but feed it via :pending-args so step-alive's hardcoded (list) doesn't drop the request arg. Acceptance: - new next/tests/smoke_kernel_route.sh: 6/6 over real HTTP (welcome /, /actors/alice, /actors/alice/outbox with gen_server-backed tip, /actors/alice/inbox, unknown-actor, via http_server:start(P, [{kernel, nx_kernel}])). - next/tests/http_server_tcp.sh: 5/5 (bumped wait_bound from 30s to 180s — cold boot is slow under sibling-loop CPU load and the per-handler scheduler ramp adds a small margin). - Erlang conformance: 761/761. Step 12's two-instance smoke test is now unblocked — its full Follow / Accept / Note flow can layer on top of this kernel-route surface. m2 plan updated. Pre-existing httpc_request.sh flakiness ("Undefined symbol: http-request" on the live-call epochs) reproduces WITHOUT this change — see git stash A/B in the investigation. Unrelated. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-06-07 20:04:19 +00:00
giles	0f85bd963a	fed-sx-m1: Step 8b-start — http_server:start/1 + dict↔proplist marshaling; live TCP smoke 5/5 ... `next/kernel/http_server.erl` gains `start/1(Port)` + `start/2(Port, Cfg)`. Both spawn an Erlang process that hosts the native `http:listen/2` accept loop with the Cfg-aware `route/2` as the handler. The blocker — the BIF wrapper in `lib/erlang/runtime.sx` had no dict↔proplist marshaling, so Erlang handler funs couldn't pattern-match on an opaque SX request dict — is resolved by a new family of helpers added next to `er-of-sx` (which is left untouched so non-HTTP callers see no behavioural drift): er-request-dict-to-proplist request dict -> [{method,<<>>},{path,<<>>},...] (atom keys) er-of-sx-deep recursive marshal: dicts -> binary-keyed proplist er-dict-to-header-proplist headers: [{<<"content-type">>,<<"text/plain">>},...] (binary keys keep arbitrary user input out of the atom table) er-proplist-to-dict response proplist -> SX dict for native serialiser er-proplist-fill! dict-set! walker over a cons-of-2-tuples er-to-sx-deep recursive marshal: cons-of-2-tuples -> nested dict er-proplist-2tuple? predicate distinguishing a header proplist from a binary body `er-bif-http-listen`'s body is updated to route through the new pair instead of `er-of-sx` / `er-to-sx`. Existing `http_listen_bif.sh` (Step 8a) still passes — the BIF's external contract (port + handler validation, registration) hasn't changed, only the request/response shape the handler sees. This commit also lands a small pre-existing unstaged refactor that was sitting in the same file (er-binary->string helper above er-bif-http-listen, a "Register everything at load time." comment move, and the binary_to_list / list_to_binary / er-iolist-walk! defines reshuffled into the er-register-builtin-bifs! body). The refactor was agreed-out-of-scope earlier in the loop but was unblocked this iteration when the user OK'd progress on 8b-start. Bundling it here keeps the lib/erlang/runtime.sx diff coherent. Tests: - `next/tests/http_marshal.sh` (10 cases) — marshaling unit tests: request dict → cons proplist; method as <<"GET">> via SX-side proplist walker; path-as-string roundtrip; nested headers reach through binary keys; response status/body field marshaling; nested headers reconstruct dict; full round-trip preserves status. - `next/tests/http_server_start.sh` (6 cases) — structural verification: http_server module loaded, start bound in module env, marshalers defined as lambdas, http:listen BIF registered. Can't invoke spawn in an Erlang test because the cooperative scheduler (`er-sched-run-all!`) drains every runnable process before returning to the caller, and the listener's accept loop never exits. - `next/tests/http_server_tcp.sh` (5 cases) — **first live end-to-end transport test in the milestone**: boots sx_server in background with FIFO-held stdin (~10s boot for all lib/erlang/*.sx loads + module compile + Unix.bind), then drives the listener via shell-side curl over real TCP. Verifies GET / → 200, GET /.well-known/sx-capabilities → 200, GET unknown → 404, POST /activity → 401 with no/bad bearer. Doubles as the smoke surface for 9a-tcp / 9b-tcp. Erlang conformance **761/761** unchanged. All standing suites stay green (http_listen_bif 5/5, log_disk 12/12, log_rotate 10/10, term_codec 18/18). Step 8b-start ticked in plans/fed-sx-milestone-1.md. Remaining in the milestone: 9a-tcp / 9b-tcp — partly covered by http_server_tcp.sh's smoke probes; the full curl-driven publish flows are the next iteration. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-06-05 20:30:15 +00:00