From 5940b9887862ebfffc41a88d3057a35c9bcf34cd Mon Sep 17 00:00:00 2001 From: giles Date: Thu, 28 May 2026 17:38:16 +0000 Subject: [PATCH] =?UTF-8?q?fed-sx-m1:=20Step=205d-pure=20=E2=80=94=20defin?= =?UTF-8?q?e=5Fregistry=20meta-projection=20fold=20+=2016=20tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- next/kernel/define_registry.erl | 68 ++++++++++++++ next/tests/define_registry_pure.sh | 139 +++++++++++++++++++++++++++++ plans/fed-sx-milestone-1.md | 3 +- 3 files changed, 209 insertions(+), 1 deletion(-) create mode 100644 next/kernel/define_registry.erl create mode 100755 next/tests/define_registry_pure.sh diff --git a/next/kernel/define_registry.erl b/next/kernel/define_registry.erl new file mode 100644 index 00000000..7cc03b4e --- /dev/null +++ b/next/kernel/define_registry.erl @@ -0,0 +1,68 @@ +-module(define_registry). +-export([fold/2, fold_fn/0, define_kind/1]). + +%% Define-registry projection fold — Erlang-fun stand-in for the +%% genesis `define-registry.sx` body. The intent is identical: a +%% projection whose state is a registry-shaped property list, fed +%% by every `Create{Define*{...}}` activity. The SX body would +%% eventually replace this once an SX-source eval bridge lets the +%% kernel evaluate the genesis fold directly; until then this +%% Erlang module proves the meta-projection mechanism wires +%% through `projection:fold_fn` and `nx_kernel` cleanly. +%% +%% State shape mirrors `registry:new()` exactly: +%% [{Kind, [{Name, Entry}, ...]}, ...] +%% so callers can use `registry:lookup/3` etc. on the result. +%% +%% Type discrimination uses atoms (`define_activity`, …). Real SX +%% would carry the string forms ("DefineActivity", …); the bridge +%% will translate. See define_kind/1 for the mapping. + +fold(Activity, State) -> + case envelope:get_field(type, Activity) of + {ok, create} -> fold_create(Activity, State); + _ -> State + end. + +fold_create(Activity, State) -> + case envelope:get_field(object, Activity) of + {ok, Obj} -> + case envelope:get_field(type, Obj) of + {ok, ObjType} -> + case define_kind(ObjType) of + not_a_define -> State; + Kind -> fold_register(Kind, Obj, State) + end; + _ -> State + end; + _ -> State + end. + +fold_register(Kind, Obj, State) -> + case envelope:get_field(name, Obj) of + {ok, Name} -> + case registry:register(Kind, Name, Obj, State) of + {ok, NewState} -> NewState; + {error, unknown_kind} -> State + end; + not_found -> State + end. + +%% fold_fn/0 — a 2-arity Erlang fun the projection module plants +%% in its record's :fold slot. Lets `projection:start_link/3` +%% wire define-registry directly. +fold_fn() -> + fun (Activity, State) -> fold(Activity, State) end. + +%% define_kind/1 — discriminator from the inner Define* object's +%% :type atom to the registry kind atom. Anything unrecognised +%% returns not_a_define so the fold treats it as a pass-through. + +define_kind(define_activity) -> activity_types; +define_kind(define_object) -> object_types; +define_kind(define_projection) -> projections; +define_kind(define_validator) -> validators; +define_kind(define_codec) -> codecs; +define_kind(define_sig_suite) -> sig_suites; +define_kind(define_audience) -> audience; +define_kind(_) -> not_a_define. diff --git a/next/tests/define_registry_pure.sh b/next/tests/define_registry_pure.sh new file mode 100755 index 00000000..232a8b43 --- /dev/null +++ b/next/tests/define_registry_pure.sh @@ -0,0 +1,139 @@ +#!/usr/bin/env bash +# next/tests/define_registry_pure.sh — Step 5d-pure test. +# +# Exercises the Erlang-fun stand-in for the define-registry +# projection fold. Activities flow: Create{Define*{...}} -> +# registry:register/4 keyed by define_kind/1. 14 cases. + +set -uo pipefail +cd "$(git rev-parse --show-toplevel)" + +SX_SERVER="${SX_SERVER:-hosts/ocaml/_build/default/bin/sx_server.exe}" +if [ ! -x "$SX_SERVER" ]; then + SX_SERVER="/root/rose-ash/hosts/ocaml/_build/default/bin/sx_server.exe" +fi +if [ ! -x "$SX_SERVER" ]; then + echo "ERROR: sx_server.exe not found." >&2 + exit 1 +fi + +VERBOSE="${1:-}" +PASS=0; FAIL=0; ERRORS="" +TMPFILE=$(mktemp); trap "rm -f $TMPFILE" EXIT + +cat > "$TMPFILE" <<'EPOCHS' +(epoch 1) +(load "lib/erlang/tokenizer.sx") +(load "lib/erlang/parser.sx") +(load "lib/erlang/parser-core.sx") +(load "lib/erlang/parser-expr.sx") +(load "lib/erlang/parser-module.sx") +(load "lib/erlang/transpile.sx") +(load "lib/erlang/runtime.sx") +(load "lib/erlang/vm/dispatcher.sx") +(epoch 2) +(eval "(er-load-gen-server!)") +(epoch 3) +(eval "(get (erlang-load-module (file-read \"next/kernel/envelope.erl\")) :name)") +(epoch 4) +(eval "(get (erlang-load-module (file-read \"next/kernel/registry.erl\")) :name)") +(epoch 5) +(eval "(get (erlang-load-module (file-read \"next/kernel/projection.erl\")) :name)") +(epoch 6) +(eval "(get (erlang-load-module (file-read \"next/kernel/define_registry.erl\")) :name)") + +;; define_kind covers all seven kinds +(epoch 10) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_activity) =:= activity_types\") :name)") +(epoch 11) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_object) =:= object_types\") :name)") +(epoch 12) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_projection) =:= projections\") :name)") +(epoch 13) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_validator) =:= validators\") :name)") +(epoch 14) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_codec) =:= codecs\") :name)") +(epoch 15) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_sig_suite) =:= sig_suites\") :name)") +(epoch 16) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(define_audience) =:= audience\") :name)") + +;; Unknown type returns not_a_define +(epoch 17) +(eval "(get (erlang-eval-ast \"define_registry:define_kind(some_other_type) =:= not_a_define\") :name)") + +;; Non-Create activity is a pass-through +(epoch 20) +(eval "(get (erlang-eval-ast \"define_registry:fold([{type, update}, {object, [{type, define_activity}, {name, pin}]}], registry:new()) =:= registry:new()\") :name)") + +;; Create{non-Define} is a pass-through +(epoch 21) +(eval "(get (erlang-eval-ast \"define_registry:fold([{type, create}, {object, [{type, note}, {name, x}]}], registry:new()) =:= registry:new()\") :name)") + +;; Create{Define*} without :name is a pass-through (preserves State) +(epoch 22) +(eval "(get (erlang-eval-ast \"define_registry:fold([{type, create}, {object, [{type, define_activity}]}], registry:new()) =:= registry:new()\") :name)") + +;; Happy path: Create{DefineActivity{name: pin}} registers under activity_types +(epoch 23) +(eval "(get (erlang-eval-ast \"Act = [{type, create}, {object, [{type, define_activity}, {name, pin}]}], S = define_registry:fold(Act, registry:new()), {ok, _} = registry:lookup(activity_types, pin, S), ok\") :name)") + +;; Multi-fold accumulates across kinds +(epoch 24) +(eval "(get (erlang-eval-ast \"A1 = [{type, create}, {object, [{type, define_activity}, {name, pin}]}], A2 = [{type, create}, {object, [{type, define_object}, {name, pin_spec}]}], A3 = [{type, create}, {object, [{type, define_projection}, {name, pin_state}]}], S = define_registry:fold(A3, define_registry:fold(A2, define_registry:fold(A1, registry:new()))), {length(registry:list(activity_types, S)), length(registry:list(object_types, S)), length(registry:list(projections, S))} =:= {1, 1, 1}\") :name)") + +;; Override: re-defining same name does not duplicate entry +(epoch 25) +(eval "(get (erlang-eval-ast \"A1 = [{type, create}, {object, [{type, define_activity}, {name, pin}, {v, 1}]}], A2 = [{type, create}, {object, [{type, define_activity}, {name, pin}, {v, 2}]}], S = define_registry:fold(A2, define_registry:fold(A1, registry:new())), case registry:lookup(activity_types, pin, S) of {ok, Entry} -> (length(registry:list(activity_types, S)) =:= 1) and (envelope:get_field(v, Entry) =:= {ok, 2}); _ -> false end\") :name)") + +;; Integration with the projection driver: define_registry as fold_fn +(epoch 26) +(eval "(get (erlang-eval-ast \"projection:start_link(dr, registry:new(), define_registry:fold_fn()), projection:async_fold(dr, [{type, create}, {object, [{type, define_activity}, {name, pin}]}]), S = projection:query(dr), case registry:lookup(activity_types, pin, S) of {ok, _} -> ok; _ -> bad end\") :name)") +EPOCHS + +OUTPUT=$(timeout 120 "$SX_SERVER" < "$TMPFILE" 2>/dev/null) + +check() { + local epoch="$1" desc="$2" expected="$3" + local actual + actual=$(echo "$OUTPUT" | awk -v e="$epoch" ' + $0 ~ "^\\(ok-len " e " " { getline; print; exit } + $0 ~ "^\\(ok " e " " { print; exit } + $0 ~ "^\\(error " e " " { print; exit } + ') + [ -z "$actual" ] && actual="" + if echo "$actual" | grep -qF -- "$expected"; then + PASS=$((PASS+1)) + [ "$VERBOSE" = "-v" ] && echo " ok $desc" + else + FAIL=$((FAIL+1)) + ERRORS+=" FAIL [$desc] (epoch $epoch) expected: $expected | actual: $actual +" + fi +} + +check 6 "define_registry module loaded" "define_registry" +check 10 "kind: define_activity" "true" +check 11 "kind: define_object" "true" +check 12 "kind: define_projection" "true" +check 13 "kind: define_validator" "true" +check 14 "kind: define_codec" "true" +check 15 "kind: define_sig_suite" "true" +check 16 "kind: define_audience" "true" +check 17 "kind: other -> not_a_define" "true" +check 20 "non-Create -> pass-through" "true" +check 21 "Create{non-Define} pass-through" "true" +check 22 "Define{} without :name no-op" "true" +check 23 "Create{DefineActivity} registers" "ok" +check 24 "multi-fold accumulates" "true" +check 25 "override preserves single entry" "true" +check 26 "projection integration" "ok" + +TOTAL=$((PASS+FAIL)) +if [ $FAIL -eq 0 ]; then + echo "ok $PASS/$TOTAL next/tests/define_registry_pure.sh passed" +else + echo "FAIL $PASS/$TOTAL passed, $FAIL failed:" + echo "$ERRORS" +fi +[ $FAIL -eq 0 ] diff --git a/plans/fed-sx-milestone-1.md b/plans/fed-sx-milestone-1.md index 28ad3402..12e5aacc 100644 --- a/plans/fed-sx-milestone-1.md +++ b/plans/fed-sx-milestone-1.md @@ -341,7 +341,7 @@ created with a known stable CID. - [x] **5a** — Pure-functional `next/kernel/registry.erl`: `new/0`, `kinds/0`, `register/4`, `lookup/3`, `list/2`. State is a property list keyed by kind atom; per-kind storage is a property list of `{Name, Entry}`. Unknown kinds rejected with `{error, unknown_kind}`. `next/tests/registry_pure.sh` (14 cases). - [x] **5b** — gen_server wrapper around the pure registry: `start_link/0`, registered name `registry`, `register/3 lookup/2 list/1 stop/0` API delegating through `gen_server:call`. `next/tests/registry_server.sh` (12 cases). Port note: each test combines start_link + ops in a single expression because spawned processes don't survive across separate `erlang-eval-ast` invocations. - [x] **5c-populate** — `bootstrap:populate_registry/0` walks `read_genesis` output and calls `registry:register/3` (the gen_server API) for each entry. Returns the total entries registered. `next/tests/bootstrap_populate.sh` (14 cases). -- [ ] **5d** — define-registry projection fold integration: incoming `Create{Define*}` activities are routed through the projection scheduler (Step 7) and update the registry. +- [x] **5d-pure** — `next/kernel/define_registry.erl` — Erlang-fun stand-in for the genesis `define-registry.sx` projection fold. Routes `Create{Define*{...}}` activities through `registry:register/4` keyed by `define_kind/1` (7 atoms: define_activity → activity_types, …). `fold_fn/0` plugs into `projection:start_link/3`. Integration test verifies the full activity → projection → registry-lookup chain. `next/tests/define_registry_pure.sh` (16 cases). **Deliverables:** @@ -1000,6 +1000,7 @@ A few things still under-specified; resolve as work begins. Newest first. One line per sub-deliverable commit. Erlang conformance gate (`bash lib/erlang/conformance.sh`) must remain 729/729 on every entry. +- **2026-05-28** — Step 5d-pure: `next/kernel/define_registry.erl` — the meta-projection fold body, in pure Erlang. State shape mirrors `registry:new()` exactly; `fold/2` dispatches Create{Define*} to `registry:register/4` keyed by `define_kind/1` (define_activity → activity_types, define_object → object_types, …). Non-Create + Create{non-Define} + Define{no :name} are all pass-throughs. Override re-registration preserves a single entry per name. `fold_fn/0` plugs the fold into `projection:start_link/3` — verified end-to-end: activity → projection async_fold → query state → registry:lookup returns the registered Object. The SX `define-registry.sx` body will replace this once an SX-source eval bridge exists; the Erlang shape proves the wiring is correct. `next/tests/define_registry_pure.sh` 16/16. Erlang conformance 729/729. - **2026-05-28** — Step 6c-schema-pure: `pipeline:stage_schema/2` accepts (Activity, SchemaLookup) where SchemaLookup is a caller-supplied callback `fun(Type) -> {ok, SchemaFn} | not_found`. Open-world default — unregistered types resolve to ok so the pipeline doesn't block activities the kernel hasn't yet learned about (tightened to strict-world in milestone 2). Activities without `:object` skip the schema check. `stage_schema/1` returns a 1-arity stage fun closed over SchemaLookup for composition with run_stages. Halt order verified end-to-end: envelope-shape errors precede schema; envelope-ok + schema-fail surfaces `schema_mismatch`. The Erlang-fun shape is the substrate-friendly stand-in for the SX `:schema` bodies in genesis; same stage shape will dispatch through an SX-source eval bridge once it exists. `next/tests/pipeline_schema.sh` 14/14. Erlang conformance 729/729. - **2026-05-28** — Step 8d-dispatch-get: format-aware versions of every GET response builder. `actor_doc_response_for/2`, `artifact_response_for/2`, `projection_response_for/2`, `projections_list_response_for/1`. Each produces `{"key":"value"}` (json/activity_json), `(key "value")` (sx), raw payload bytes (cbor stub), or the existing text form. `dispatch` refactored to `/3` with a backward-compat `dispatch/2` wrapper. Route extracts Format via `accept_format_from/1` once at the top and threads it through dispatch. End-to-end GETs with `Accept: application/json` / `application/sx` verified for all three dynamic-prefix routes + the projections-list bare-path route. Step 8d effectively complete — format dispatch + Content-Type live on every non-static response. `next/tests/http_get_format.sh` 17/17. Erlang conformance 729/729. - **2026-05-28** — Step 8d-dispatch-post: `handle_post_activity` extracts the Accept format via `accept_format_from/1` and threads it into `publish_if_kernel/2`. Both success paths emit format-specific bodies: `cid_response_for/2` produces `{"cid":""}\n` (json/activity_json), `(cid "")\n` (sx), raw CID bytes (cbor), or the existing text form; `post_activity_response_for/1` mirrors for the kernel-absent stub. Each response carries the matching Content-Type. End-to-end POSTs with `Accept: application/json` / `application/sx` verified through the full HTTP→nx_kernel→publish→cid_response_for chain. `next/tests/http_post_format.sh` 13/13. Erlang conformance 729/729.