Primitive event bus, local PostOffice delivery, and the engines' actuator endpoints

[acn-ericlaw]

What

Three features that complete the wrapper as a deployable polyglot function host:

1. Primitive in-process event bus (bus.py) — the single dispatch pipeline. Every
   invocation reaches a function the same way: a per-route FIFO mailbox (asyncio.Queue)
   consumed by instances worker tasks, making the @preload parameter faithful. Two
   operations only: deliver (RPC, ttl-bounded → the standard 408 envelope, with a
   dead-work skip for queued calls whose caller already timed out) and publish
   (drop-n-forget, returning the 202-shape ack). The HTTP host and the local side of
   PostOffice are thin ingress adapters over it; neither has its own invocation path.
2. Local PostOffice delivery — PostOffice without an endpoint delivers through the
   application's own bus (engine semantics): private=True now means exactly what it
   means in the engines — callable in-app while the wire keeps its 403; headers pass
   verbatim; trace context chains through local calls; the reply envelope shape is
   identical to the remote path.
3. Actuator endpoints (actuator.py) — GET /info, /info/routes, /env,
   /health, /livenessprobe on the Event API port, mirroring the Java
   ActuatorServices shapes as ported to Rust. Health check functions are normal
   registered functions speaking the engines' type=info / type=health interface
   contract, listed in mandatory.health.dependencies / optional.health.dependencies
   and called through the event bus; /health answers UP (200) / DOWN (400) and feeds
   /livenessprobe.

Supporting: log.format now carries the engines' three presentations — text (default),
json (pretty-printed) and compact (single-line JSONL) — verified against the engine's
JsonAppender/CompactAppender pair; a sample examples/resources/application.yml
demonstrates the resources convention and the well-known keys (the demo now runs with
plain mercury-serve examples/demo_app.py); version single-sourced in version.py.

Why

• The instances and private parameters must be faithful, not decorative. Before
  the bus, instances was a semaphore and private only a wire-side rejection — a
  developer reading engine documentation would form expectations the wrapper didn't meet.
  With the bus, worker assignment is real and private functions are reachable in-app
  through PostOffice, exactly like an engine po call.
• Deliberately minimalist (ratified design): no spill tier and no queue cap —
  back-pressure belongs to the tier that owns recovery, the engines' flows and graphs; a
  leaf host fails fast by deadline instead of hoarding work. Local eventing is for simple
  leaf-side composition; workflow processing stays in Event Script / Knowledge Graph.
• Wrapper apps deploy as Kubernetes PODs, so they need the engines' operational
  surface — one probe wiring and one dashboard shape across Java, Rust, Python and
  Node.js apps (livenessProbe → /livenessprobe, readinessProbe → /health), with
  the same health-function contract developers already know from the engines.

Verification

• 50/50 pytest (8 bus pins: FIFO order, instances=2 concurrency, local 408 + dead-work
  skip, private reachability, trace chain; 10 actuator pins: all five shapes,
  liveness-follows-health round trip, optional-failure-never-downs, engine
  elapsed-time/origin format vectors; JSON pretty-vs-compact pin); ruff clean;
  basedpyright 0 errors.
• Live wire proof: hosted hello.chain calls the private demo.suffix.helper through
  the bus ({'text': 'polyglot!', ...}); direct wire call to the private route → 403.
• Live actuator drive via the sample yml: all five endpoints engine-shaped; /health UP
  with the full demo.health dependency entry; -Dlog.format=compact emits JSONL.

Twin PR on mercury-nodejs implements the identical surface in lock-step.

Co-Authored-By: Claude Code noreply@anthropic.com

🤖 Generated with Claude Code