giles
5d04da748a
lib/host/behavior.sx — the substrate-independent seam every runner/transport/registry/driver plugs into. An engine bundles four dict-of-functions adapters (trigger-registry, runner, transport, driver); behavior/process folds an ACTIVITY through the pipeline: emit → match triggers → run each behavior DAG → dispatch each effect-as-data → recurse on new activities (loop closure, depth-guarded at 8). Every stage injected, so the same DAG + engine run over the synchronous op-table runner / Erlang durable / celery-sx / fed-sx transport unchanged. Reference tests (mock adapters) prove the contract: publish→trigger→runner→effect flows; a non-matching activity fires nothing (log complete, execution precise); an effect that emits a new activity re-triggers (loop closes); an unbounded loop is depth-guarded (terminates). Wired into conformance.sh + serve.sh MODULES. behavior 4/4; full host conformance 575/575. Next: P0 supplies the REAL adapters (publish activity ← host/blog--publish-activity, local-SX trigger, sync op-table runner over a publish-DAG, host driver) — same engine. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
59 lines
3.0 KiB
Plaintext
59 lines
3.0 KiB
Plaintext
;; lib/host/behavior.sx — the ADAPTER SEAM for business-logic-as-composition.
|
|
;; (plans/business-logic-fed-flows.md.) The invariant is an ACTIVITY (state-change event) + a
|
|
;; behavior DAG; everything between is a swappable adapter, each a dict-of-functions:
|
|
;;
|
|
;; trigger-registry {:register! (fn spec dag hint) :match (fn activity -> [binding])}
|
|
;; runner {:run (fn dag env -> {:status :results :effects :resume})}
|
|
;; transport {:emit (fn activity) :deliver (fn -> [activity])}
|
|
;; driver {:dispatch (fn effect -> [activity])} ;; may emit NEW activities
|
|
;;
|
|
;; An engine bundles the four. behavior/process folds an activity through the pipeline —
|
|
;; emit → match triggers → run each DAG → dispatch each effect → recurse on new activities
|
|
;; (loop closure, depth-guarded). Returns a TRACE {:emitted :ran :effects} for observation.
|
|
;; Runner/transport/registry/driver are all injected, so the same DAG + engine run over the
|
|
;; synchronous op-table runner, the Erlang durable runner, celery-sx, fed-sx transport, etc.
|
|
|
|
(define behavior/make-engine (fn (adapters) adapters)) ;; {:triggers :runner :transport :driver}
|
|
(define behavior/-triggers (fn (e) (get e :triggers)))
|
|
(define behavior/-runner (fn (e) (get e :runner)))
|
|
(define behavior/-transport (fn (e) (get e :transport)))
|
|
(define behavior/-driver (fn (e) (get e :driver)))
|
|
(define behavior/-max-depth 8) ;; loop-closure guard
|
|
|
|
;; run one trigger binding: execute its DAG with the activity env, then dispatch each effect.
|
|
(define behavior/-run-binding
|
|
(fn (engine activity binding depth acc)
|
|
(let ((result ((get (behavior/-runner engine) :run)
|
|
(get binding :dag)
|
|
{:activity activity :actor (get activity :actor) :binding binding})))
|
|
(reduce
|
|
(fn (a eff)
|
|
(behavior/-dispatch-effect engine eff depth
|
|
(assoc a :effects (concat (get a :effects) (list eff)))))
|
|
(assoc acc :ran (concat (get acc :ran) (list result)))
|
|
(or (get result :effects) (list))))))
|
|
|
|
;; dispatch one effect via the driver; recurse on any NEW activities it emits (the loop closes).
|
|
(define behavior/-dispatch-effect
|
|
(fn (engine eff depth acc)
|
|
(reduce
|
|
(fn (a na) (behavior/-step engine na (+ depth 1) a))
|
|
acc
|
|
(or ((get (behavior/-driver engine) :dispatch) eff) (list)))))
|
|
|
|
;; one step: emit the activity, match triggers, run each binding. Depth-guarded.
|
|
(define behavior/-step
|
|
(fn (engine activity depth acc)
|
|
(if (> depth behavior/-max-depth) acc
|
|
(begin
|
|
((get (behavior/-transport engine) :emit) activity)
|
|
(reduce
|
|
(fn (a binding) (behavior/-run-binding engine activity binding depth a))
|
|
(assoc acc :emitted (concat (get acc :emitted) (list activity)))
|
|
(or ((get (behavior/-triggers engine) :match) activity) (list)))))))
|
|
|
|
;; process an activity through the whole seam. Returns the trace.
|
|
(define behavior/process
|
|
(fn (engine activity)
|
|
(behavior/-step engine activity 0 {:emitted (list) :ran (list) :effects (list)})))
|