@nanobpm/agentic 0.1.0

package/src/relay/relay-family.test.ts

@@ -0,0 +1,236 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { Frame } from "../protocol/index.ts";
+import { RelayHub, RelayMessageError } from "./relay-family.ts";
+import type { RelayConnection } from "./relay-family.ts";
+
+class FakeRegistry {
+  readonly live = new Set<string>();
+  has(id: string): boolean {
+    return this.live.has(id);
+  }
+}
+
+class FakeConn implements RelayConnection {
+  readonly id: string;
+  readonly registry: FakeRegistry;
+  readonly sent: Frame[] = [];
+  constructor(id: string, registry: FakeRegistry) {
+    this.id = id;
+    this.registry = registry;
+    registry.live.add(id);
+  }
+  send(frame: Frame): void {
+    this.sent.push(frame);
+  }
+  disconnect(): void {
+    this.registry.live.delete(this.id);
+  }
+}
+
+function produce(stream: string, incarnation: number, chunk: string): Frame {
+  return { lane: "bulk", family: "relay", seq: 0, payload: { op: "produce", stream, incarnation, chunk } };
+}
+function subscribe(stream: string, from: number, credit: number): Frame {
+  return { lane: "control", family: "relay", seq: 0, payload: { op: "subscribe", stream, from, credit } };
+}
+function credit(n: number): Frame {
+  return { lane: "control", family: "relay", seq: 0, payload: { op: "credit", credit: n } };
+}
+
+function field(payload: unknown, key: string): unknown {
+  return typeof payload === "object" && payload !== null ? Reflect.get(payload, key) : undefined;
+}
+
+/** Chunks the consumer received as bulk data frames, in emission order. */
+function dataChunks(conn: FakeConn): string[] {
+  return conn.sent
+    .filter((f) => f.lane === "bulk" && field(f.payload, "op") === undefined)
+    .map((f) => String(field(f.payload, "chunk")));
+}
+function dataOffsets(conn: FakeConn): number[] {
+  return conn.sent
+    .filter((f) => f.lane === "bulk" && field(f.payload, "op") === undefined)
+    .map((f) => Number(field(f.payload, "offset")));
+}
+function acks(conn: FakeConn): Frame[] {
+  return conn.sent.filter((f) => field(f.payload, "op") === "subscribed");
+}
+
+test("produce appends to the stream ring and assigns authoritative offsets", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  relay.handle(produce("t", 1, "a"), prod);
+  relay.handle(produce("t", 1, "b"), prod);
+  const ring = relay.ring("t");
+  assert.ok(ring);
+  assert.equal(ring.nextOffset, 2);
+  assert.deepEqual(ring.since(0).entries, [
+    { offset: 0, chunk: "a" },
+    { offset: 1, chunk: "b" },
+  ]);
+});
+
+test("a subscriber gets a control ack then the live stream broadcast to it", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const cons = new FakeConn("c", reg);
+  relay.handle(subscribe("t", 0, 100), cons);
+  relay.handle(produce("t", 1, "x"), prod);
+  relay.handle(produce("t", 1, "y"), prod);
+  assert.equal(acks(cons).length, 1);
+  assert.equal(field(acks(cons)[0]?.payload, "gap"), false);
+  assert.deepEqual(dataChunks(cons), ["x", "y"]);
+});
+
+test("resume-from-offset: a reconnecting consumer receives only the tail it is missing", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  for (const c of ["a", "b", "c", "d"]) {
+    relay.handle(produce("t", 1, c), prod);
+  }
+  // Consumer had received through offset 1 (a,b); it reconnects on a new socket
+  // and resumes from offset 2.
+  const resumed = new FakeConn("c2", reg);
+  relay.handle(subscribe("t", 2, 100), resumed);
+  assert.equal(field(acks(resumed)[0]?.payload, "gap"), false);
+  assert.deepEqual(dataChunks(resumed), ["c", "d"]);
+  assert.deepEqual(dataOffsets(resumed), [2, 3]);
+  // The stream survives the reconnect: subsequent live chunks flow to the resumed consumer.
+  relay.handle(produce("t", 1, "e"), prod);
+  assert.deepEqual(dataChunks(resumed), ["c", "d", "e"]);
+});
+
+test("resume flags a gap when the requested offset was already evicted", () => {
+  const relay = new RelayHub({ ringCapacity: 2 });
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  for (const c of ["a", "b", "c", "d"]) {
+    relay.handle(produce("t", 1, c), prod); // retains offsets 2,3
+  }
+  const cons = new FakeConn("c", reg);
+  relay.handle(subscribe("t", 0, 100), cons);
+  assert.equal(field(acks(cons)[0]?.payload, "gap"), true);
+  assert.deepEqual(dataOffsets(cons), [2, 3]); // best-effort tail
+});
+
+test("credit-based backpressure: bulk data waits for credit; control ack is not gated", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const cons = new FakeConn("c", reg);
+  relay.handle(subscribe("t", 0, 0), cons); // zero credit
+  relay.handle(produce("t", 1, "x"), prod);
+  relay.handle(produce("t", 1, "y"), prod);
+  // The control-lane ack arrived; no bulk data yet (starved of credit).
+  assert.equal(acks(cons).length, 1);
+  assert.deepEqual(dataChunks(cons), []);
+  // Consumer grants credit → buffered data drains in order.
+  relay.handle(credit(5), cons);
+  assert.deepEqual(dataChunks(cons), ["x", "y"]);
+});
+
+test("a bulk storm to a starved consumer never blocks another consumer's control ack", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const slow = new FakeConn("slow", reg);
+  const fast = new FakeConn("fast", reg);
+  relay.handle(subscribe("t", 0, 0), slow); // slow consumer, no credit
+  for (let i = 0; i < 500; i++) {
+    relay.handle(produce("t", 1, `b${i}`), prod);
+  }
+  assert.deepEqual(dataChunks(slow), []); // slow consumer is backpressured
+  // A brand-new consumer still gets its control ack immediately.
+  relay.handle(subscribe("t", 500, 0), fast);
+  assert.equal(acks(fast).length, 1);
+});
+
+test("stale incarnations are fenced: a lower incarnation is rejected and not stored", () => {
+  const fenced: Array<{ stream: string; incarnation: number; current: number }> = [];
+  const relay = new RelayHub({ onFenced: (stream, incarnation, current) => fenced.push({ stream, incarnation, current }) });
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  relay.handle(produce("t", 2, "new"), prod);
+  relay.handle(produce("t", 1, "zombie"), prod); // stale → fenced
+  assert.deepEqual(fenced, [{ stream: "t", incarnation: 1, current: 2 }]);
+  assert.deepEqual(relay.ring("t")?.since(0).entries.map((e) => e.chunk), ["new"]);
+});
+
+test("a newer incarnation takes over and its chunks are appended", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  relay.handle(produce("t", 1, "old"), prod);
+  relay.handle(produce("t", 2, "new"), prod); // takeover
+  assert.equal(relay.fence.current("t"), 2);
+  assert.deepEqual(relay.ring("t")?.since(0).entries.map((e) => e.chunk), ["old", "new"]);
+});
+
+test("a disconnected consumer is pruned lazily on the next inbound frame", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const cons = new FakeConn("c", reg);
+  relay.handle(subscribe("t", 0, 100), cons);
+  assert.equal(relay.subscriberCount, 1);
+  cons.disconnect(); // registry no longer has "c"
+  relay.handle(produce("t", 1, "x"), prod); // triggers prune
+  assert.equal(relay.subscriberCount, 0);
+  assert.deepEqual(dataChunks(cons), []); // nothing sent to the dead socket
+});
+
+test("a malformed relay payload is reported to onError and dropped", () => {
+  const errors: unknown[] = [];
+  const relay = new RelayHub({ onError: (err) => errors.push(err) });
+  const reg = new FakeRegistry();
+  const conn = new FakeConn("c", reg);
+  const bad: Frame = { lane: "control", family: "relay", seq: 0, payload: { op: "produce", stream: "" } };
+  relay.handle(bad, conn);
+  assert.equal(errors.length, 1);
+  assert.ok(errors[0] instanceof RelayMessageError);
+  assert.equal(relay.streamCount, 0);
+});
+
+test("a credit grant before subscribe pre-loads the consumer's budget", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const cons = new FakeConn("c", reg);
+  relay.handle(credit(10), cons); // credit first
+  relay.handle(subscribe("t", 0, 0), cons); // subscribe with no additional credit
+  relay.handle(produce("t", 1, "x"), prod);
+  assert.deepEqual(dataChunks(cons), ["x"]); // pre-loaded credit let it flow
+});
+
+test("the subscribed ack is emitted before a previously buffered bulk tail flushes", () => {
+  const relay = new RelayHub();
+  const reg = new FakeRegistry();
+  const prod = new FakeConn("p", reg);
+  const cons = new FakeConn("c", reg);
+  // Subscribe to A with zero credit, then produce bulk that stays buffered.
+  relay.handle(subscribe("A", 0, 0), cons);
+  relay.handle(produce("A", 1, "a0"), prod);
+  relay.handle(produce("A", 1, "a1"), prod);
+  assert.deepEqual(dataChunks(cons), []); // starved of credit → buffered
+  const before = cons.sent.length;
+  // Subscribe to B WITH credit. Releasing that credit must NOT flush A's buffered
+  // bulk tail out ahead of B's control ack — the ack rides first.
+  relay.handle(subscribe("B", 0, 100), cons);
+  const emitted = cons.sent.slice(before);
+  const ackIndex = emitted.findIndex((f) => field(f.payload, "op") === "subscribed");
+  const firstBulkIndex = emitted.findIndex((f) => f.lane === "bulk" && field(f.payload, "op") === undefined);
+  assert.ok(ackIndex >= 0, "B's control ack was emitted");
+  assert.ok(firstBulkIndex >= 0, "A's buffered bulk flushed once credit was granted");
+  assert.ok(ackIndex < firstBulkIndex, "the ack precedes the flushed bulk tail");
+});
+
+test("RelayHub validates capacity/credit options up-front and fails fast", () => {
+  assert.throws(() => new RelayHub({ ringCapacity: 0 }), RangeError);
+  assert.throws(() => new RelayHub({ ringCapacity: 1.5 }), RangeError);
+  assert.throws(() => new RelayHub({ bulkCapacity: 0 }), RangeError);
+  assert.throws(() => new RelayHub({ defaultCredit: -1 }), RangeError);
+});

package/src/relay/relay-family.ts

@@ -0,0 +1,336 @@
+/**
+ * The `relay` message family — S5's live-terminal relay, attached to the S1 hub
+ * as its OWN module via the `registerFamilyHandler(family, handler)` seam. It
+ * never edits a shared dispatch switch: {@link registerRelayFamily} claims the
+ * `relay` family key (from the S0 {@link MESSAGE_FAMILIES} set) and the hub
+ * derives routing from that registration.
+ *
+ * It composes the three S5 primitives:
+ *  - {@link ReplayRing}      — per-stream resume-from-offset store,
+ *  - {@link IncarnationFence} — fences stale producers off a stream,
+ *  - {@link QosScheduler}    — per-consumer three-lane egress with credit-based
+ *                              backpressure (bulk never blocks control).
+ *
+ * ## Relay sub-protocol (carried in the `relay` family payload)
+ *
+ * Inbound (peer → hub):
+ *  - `{ op: "produce",   stream, incarnation, chunk }` — a producer appends a
+ *    chunk; the hub assigns the authoritative offset and fences stale incarnations.
+ *  - `{ op: "subscribe", stream, from?, credit? }`     — a consumer (re)attaches
+ *    and resumes from `from` (default 0); the retained tail is replayed.
+ *  - `{ op: "credit",    credit }`                    — a consumer grants more
+ *    bulk credit (backpressure) for its whole egress budget.
+ *
+ * Outbound (hub → consumer):
+ *  - a `data` frame is a pure S0 {@link RelayPayload} `{ stream, offset, chunk }`
+ *    on the `bulk` lane;
+ *  - a `subscribed` ack rides the `control` lane and reports `{ gap, nextOffset }`.
+ */
+import { MAX_SEQ } from "../protocol/index.ts";
+import type { Frame, MessageFamily, RelayPayload } from "../protocol/index.ts";
+import type { AgenticHub } from "../channel/index.ts";
+import { IncarnationFence } from "./incarnation.ts";
+import { ReplayRing } from "./ring.ts";
+import { QosScheduler } from "./scheduler.ts";
+import { isNonNegInt, isPosInt } from "./validate.ts";
+
+/** The relay family key, from the S0 canonical family set (the one source of truth). */
+export const RELAY_FAMILY: MessageFamily = "relay";
+
+/**
+ * The minimal connection surface the relay module needs. It is a structural
+ * subset of the hub's `HubConnection`, so the module is unit-testable with a
+ * fake connection and needs no compile dependency on the hub's concrete type.
+ */
+export interface RelayConnection {
+  readonly id: string;
+  /** The shared registry — its `has(id)` is the liveness source of truth. */
+  readonly registry: { has(id: string): boolean };
+  /** Send one already-built frame back on this connection. */
+  send(frame: Frame): void;
+}
+
+export interface RelayHubOptions {
+  /** Retained chunks per stream (resume window). Default 1024. */
+  readonly ringCapacity?: number;
+  /** Max buffered bulk frames per consumer before oldest is shed. Default 1024. */
+  readonly bulkCapacity?: number;
+  /** Bulk credit a consumer starts with before it grants its own. Default 0. */
+  readonly defaultCredit?: number;
+  /** Notified when a producer frame is fenced as a stale incarnation. */
+  readonly onFenced?: (stream: string, incarnation: number, current: number) => void;
+  /** Notified of a malformed relay message or a send failure. */
+  readonly onError?: (err: unknown, connectionId?: string) => void;
+}
+
+interface Subscriber {
+  readonly conn: RelayConnection;
+  readonly scheduler: QosScheduler;
+  readonly streams: Set<string>;
+  seq: number;
+}
+
+const DEFAULT_RING_CAPACITY = 1024;
+const DEFAULT_BULK_CAPACITY = 1024;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function nonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+/** A parsed, validated inbound relay message. */
+type RelayInbound =
+  | { readonly op: "produce"; readonly stream: string; readonly incarnation: number; readonly chunk: string }
+  | { readonly op: "subscribe"; readonly stream: string; readonly from: number; readonly credit: number }
+  | { readonly op: "credit"; readonly credit: number };
+
+/**
+ * The hub-side relay state machine: per-stream replay rings + incarnation fence,
+ * and per-consumer QoS schedulers. Construct via {@link registerRelayFamily}, or
+ * directly for unit testing and then drive with {@link RelayHub.handle}.
+ */
+export class RelayHub {
+  readonly #rings = new Map<string, ReplayRing>();
+  readonly #fence = new IncarnationFence();
+  readonly #subscribers = new Map<string, Subscriber>();
+  readonly #ringCapacity: number;
+  readonly #bulkCapacity: number;
+  readonly #defaultCredit: number;
+  readonly #onFenced: RelayHubOptions["onFenced"];
+  readonly #onError: RelayHubOptions["onError"];
+
+  constructor(options: RelayHubOptions = {}) {
+    this.#ringCapacity = options.ringCapacity ?? DEFAULT_RING_CAPACITY;
+    this.#bulkCapacity = options.bulkCapacity ?? DEFAULT_BULK_CAPACITY;
+    this.#defaultCredit = options.defaultCredit ?? 0;
+    // Validate up-front so misconfiguration fails fast at construction, rather
+    // than throwing lazily from inside #ringFor/#subscriberFor on the first
+    // frame (where the throw would escape handle() and bypass onError).
+    if (!isPosInt(this.#ringCapacity)) {
+      throw new RangeError(`RelayHub ringCapacity must be a positive integer, got ${this.#ringCapacity}`);
+    }
+    if (!isPosInt(this.#bulkCapacity)) {
+      throw new RangeError(`RelayHub bulkCapacity must be a positive integer, got ${this.#bulkCapacity}`);
+    }
+    if (!isNonNegInt(this.#defaultCredit)) {
+      throw new RangeError(`RelayHub defaultCredit must be a non-negative integer, got ${this.#defaultCredit}`);
+    }
+    this.#onFenced = options.onFenced;
+    this.#onError = options.onError;
+  }
+
+  /** Number of streams with a replay ring. */
+  get streamCount(): number {
+    return this.#rings.size;
+  }
+
+  /** Number of tracked consumer subscribers. */
+  get subscriberCount(): number {
+    return this.#subscribers.size;
+  }
+
+  /** The replay ring for a stream, if one exists (for inspection/tests). */
+  ring(stream: string): ReplayRing | undefined {
+    return this.#rings.get(stream);
+  }
+
+  /** The incarnation fence (for inspection/tests). */
+  get fence(): IncarnationFence {
+    return this.#fence;
+  }
+
+  /** Whether a connection currently has a subscriber record. */
+  hasSubscriber(id: string): boolean {
+    return this.#subscribers.has(id);
+  }
+
+  /**
+   * Handle one inbound `relay` frame from `conn`. This is the function attached
+   * to the hub's family seam; it is safe to call directly in tests.
+   */
+  handle(frame: Frame, conn: RelayConnection): void {
+    this.#pruneDead();
+    const msg = this.#parse(frame.payload);
+    if (msg === null) {
+      this.#onError?.(new RelayMessageError(frame.payload), conn.id);
+      return;
+    }
+    switch (msg.op) {
+      case "produce":
+        this.#onProduce(msg.stream, msg.incarnation, msg.chunk);
+        return;
+      case "subscribe":
+        this.#onSubscribe(conn, msg.stream, msg.from, msg.credit);
+        return;
+      case "credit":
+        this.#onCredit(conn, msg.credit);
+        return;
+    }
+  }
+
+  #onProduce(stream: string, incarnation: number, chunk: string): void {
+    if (!this.#fence.admit(stream, incarnation)) {
+      this.#onFenced?.(stream, incarnation, this.#fence.current(stream) ?? incarnation);
+      return;
+    }
+    const entry = this.#ringFor(stream).append(chunk);
+    for (const sub of this.#subscribers.values()) {
+      if (sub.streams.has(stream)) {
+        this.#emitData(sub, stream, entry.offset, entry.chunk);
+      }
+    }
+  }
+
+  #onSubscribe(conn: RelayConnection, stream: string, from: number, credit: number): void {
+    const sub = this.#subscriberFor(conn);
+    sub.streams.add(stream);
+    const ring = this.#ringFor(stream);
+    const slice = ring.since(from);
+    // Control-lane ack FIRST — before granting credit. It tells the consumer
+    // where the resume actually started and whether it lost chunks (gap), and it
+    // must ride ahead of the replayed bulk tail. Emitting it before grantCredit
+    // ensures a bulk tail buffered from an earlier subscription on this same
+    // connection cannot flush out ahead of this ack when credit is released.
+    this.#emit(sub, "control", {
+      op: "subscribed",
+      stream,
+      gap: slice.gap,
+      nextOffset: ring.nextOffset,
+    });
+    if (credit > 0) {
+      sub.scheduler.grantCredit(credit);
+    }
+    for (const entry of slice.entries) {
+      this.#emitData(sub, stream, entry.offset, entry.chunk);
+    }
+  }
+
+  #onCredit(conn: RelayConnection, credit: number): void {
+    // A credit grant may arrive before subscribe (pre-loading the consumer's
+    // budget); create the subscriber record so the credit is not lost.
+    const sub = this.#subscriberFor(conn);
+    sub.scheduler.grantCredit(credit);
+  }
+
+  #emitData(sub: Subscriber, stream: string, offset: number, chunk: string): void {
+    const payload: RelayPayload = { stream, offset, chunk };
+    this.#enqueue(sub, "bulk", payload);
+  }
+
+  #emit(sub: Subscriber, lane: Frame["lane"], payload: unknown): void {
+    this.#enqueue(sub, lane, payload);
+  }
+
+  #enqueue(sub: Subscriber, lane: Frame["lane"], payload: unknown): void {
+    const frame: Frame = { lane, family: RELAY_FAMILY, seq: sub.seq, payload };
+    sub.seq = sub.seq >= MAX_SEQ ? 0 : sub.seq + 1;
+    try {
+      sub.scheduler.enqueue(frame);
+    } catch (err) {
+      this.#onError?.(err, sub.conn.id);
+    }
+  }
+
+  #ringFor(stream: string): ReplayRing {
+    let ring = this.#rings.get(stream);
+    if (ring === undefined) {
+      ring = new ReplayRing({ capacity: this.#ringCapacity });
+      this.#rings.set(stream, ring);
+    }
+    return ring;
+  }
+
+  #subscriberFor(conn: RelayConnection): Subscriber {
+    let sub = this.#subscribers.get(conn.id);
+    if (sub === undefined) {
+      sub = {
+        conn,
+        scheduler: new QosScheduler({
+          sink: (frame) => conn.send(frame),
+          credit: this.#defaultCredit,
+          bulkCapacity: this.#bulkCapacity,
+        }),
+        streams: new Set(),
+        seq: 0,
+      };
+      this.#subscribers.set(conn.id, sub);
+    }
+    return sub;
+  }
+
+  /**
+   * Drop subscriber records whose connection is no longer live (the S1 registry
+   * removed it on close). The hub does not surface a per-family close hook, so
+   * the registry's `has(id)` is the liveness source of truth and cleanup is
+   * lazy — run on every inbound frame.
+   */
+  #pruneDead(): void {
+    for (const [id, sub] of this.#subscribers) {
+      if (!sub.conn.registry.has(id)) {
+        sub.scheduler.clear();
+        this.#subscribers.delete(id);
+      }
+    }
+  }
+
+  #parse(payload: unknown): RelayInbound | null {
+    if (!isPlainObject(payload)) {
+      return null;
+    }
+    const op = payload.op;
+    if (op === "produce") {
+      if (!nonEmptyString(payload.stream) || !isNonNegInt(payload.incarnation) || typeof payload.chunk !== "string") {
+        return null;
+      }
+      return { op, stream: payload.stream, incarnation: payload.incarnation, chunk: payload.chunk };
+    }
+    if (op === "subscribe") {
+      if (!nonEmptyString(payload.stream)) {
+        return null;
+      }
+      const from = payload.from === undefined ? 0 : payload.from;
+      if (!isNonNegInt(from)) {
+        return null;
+      }
+      const credit = payload.credit === undefined ? 0 : payload.credit;
+      if (!isNonNegInt(credit)) {
+        return null;
+      }
+      return { op, stream: payload.stream, from, credit };
+    }
+    if (op === "credit") {
+      if (!isNonNegInt(payload.credit)) {
+        return null;
+      }
+      return { op, credit: payload.credit };
+    }
+    return null;
+  }
+}
+
+/** Raised (to `onError`) when an inbound relay payload does not match the sub-protocol. */
+export class RelayMessageError extends Error {
+  readonly payload: unknown;
+  constructor(payload: unknown) {
+    super("malformed relay message payload");
+    this.name = "RelayMessageError";
+    this.payload = payload;
+  }
+}
+
+/**
+ * Attach the `relay` family to a hub via the S1 registration seam and return the
+ * {@link RelayHub} driving it. This is the canonical entry point; it does NOT
+ * edit any shared dispatch switch — the hub derives routing from this
+ * registration, and a second registration of `relay` is rejected by the seam.
+ */
+export function registerRelayFamily(hub: AgenticHub, options: RelayHubOptions = {}): RelayHub {
+  const relay = new RelayHub(options);
+  hub.registerFamilyHandler(RELAY_FAMILY, (frame, ctx) => {
+    relay.handle(frame, ctx);
+  });
+  return relay;
+}