#Posoco events

///|
pub(all) enum SprintEvent {
  Started(Int32)
  Finished
}

///|
pub(all) extenum @events.Event += {
  SprintChanged(SprintEvent)
}

///|
test "a community protocol extends the open event type" {
  let event : @events.Event = SprintChanged(Started(3))
  let described = match event {
    SprintChanged(Started(sprint)) => "started #\{sprint}"
    SprintChanged(Finished) => "finished"
    @events.Core(_) => "core notification"
    _ => "another protocol"
  }
  assert_eq(described, "started #3")
}

#One resource per Agent

1. Define an ADT and extend the open @posoco.Event.
2. let system = @posoco.EventSystem(). While no Agent owns it, the system already grants publisher(owner~) capabilities and accepts subscribe.
3. Give a plain object its Events with system.publisher(owner="status_bar"). The grant is bound to Extension("status_bar"), the object needs no Lifecycle, and the capability stays valid after the Agent takes over.
4. Compose Agent(exts~, config~, events=system). Construction takes exclusive ownership before aggregation; a second Agent on the same value is rejected and leaves the first Agent working.
5. Extensions can still declare requires: [@posoco.Capability::Events] and lifecycle: [self], then obtain view.events() in Lifecycle::on_compose. An object that needs to publish earlier can instead receive its capability from the host, including before that object's construction.
6. Hosts subscribe with system.subscribe(handler) before composition or with agent.subscribe_events(handler) afterwards, optionally filtering with namespace_=Some(Extension(id)) or namespace_=Some(Posoco). None means all namespaces.
7. Handle every Result, retain the subscription, and call cancel() when done. After Agent::shutdown — or system.close() on a system no Agent owns — publisher grants, publications and new subscriptions return Err(Closed); an extension publishing Core returns Err(ReservedEvent).

///|
let system = @posoco.EventSystem()
// An untaken system already accepts listeners and grants capabilities.

///|
let subscription = system.subscribe(handler).unwrap()
// `publisher.publish(...)` is tagged Extension("status_bar") from now on,
// including after the Agent takes the resource over.

///|
let publisher = system.publisher(owner="status_bar").unwrap()

///|
let agent = @posoco.Agent(exts~, config~, events=system)
// Retain subscription until its listener is no longer needed, then cancel it.
// `Agent::shutdown` closes the resource; retained capabilities return Closed.

///|
test "subscribe to typed deliveries and cancel" {
  let delivered : Array[String] = []
  let dispatch : Ref[(@events.EventEnvelope) -> Unit] = Ref(fn(_) { () })
  let events = @events.Events::from_callbacks(
    publish=fn(_event, _scope) { Ok(()) },
    subscribe=fn(handler, _namespace_) {
      // A real runtime records the handler and filters by namespace.
      dispatch.val = handler
      Ok(@events.Subscription::from_cancel(fn() { () }))
    },
  )
  let subscription = events.subscribe(fn(envelope) {
    match envelope.event {
      SprintChanged(Started(sprint)) =>
        // The envelope namespace is system-produced delivery metadata.
        match envelope.namespace_of() {
          Extension("sprint") => delivered.push("sprint started #\{sprint}")
          _ => delivered.push("unexpected namespace")
        }
      _ => ()
    }
  })
  guard subscription is Ok(handle) else { fail("expected a subscription") }
  (dispatch.val)(
    @events.EventEnvelope(
      namespace_=@events.Extension("sprint"),
      event=SprintChanged(Started(4)),
    ),
  )
  handle.cancel()
  handle.cancel()
  assert_eq(delivered, ["sprint started #4"])
}