@moxxy/channel-kit 0.27.0

package/src/frame-pump.test.ts

@@ -0,0 +1,209 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { FramePump, type FrameSink } from './frame-pump.js';
+
+interface SinkCall {
+  readonly op: 'send' | 'edit';
+  readonly id?: number;
+  readonly text: string;
+  readonly final: boolean;
+}
+
+function makeSink(opts: { failSends?: boolean } = {}): { sink: FrameSink<number>; calls: SinkCall[] } {
+  const calls: SinkCall[] = [];
+  let nextId = 0;
+  const sink: FrameSink<number> = {
+    async send(text, final) {
+      calls.push({ op: 'send', text, final });
+      if (opts.failSends) return null;
+      return ++nextId;
+    },
+    async edit(id, text, final) {
+      calls.push({ op: 'edit', id, text, final });
+    },
+  };
+  return { sink, calls };
+}
+
+describe('FramePump', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('sends the first frame, then edits the same message for later frames', async () => {
+    const { sink, calls } = makeSink();
+    let text = '';
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => text });
+
+    text = 'Hello';
+    pump.scheduleEdit();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(calls).toEqual([{ op: 'send', text: 'Hello', final: false }]);
+    expect(pump.messageId).toBe(1);
+
+    text = 'Hello, world';
+    pump.scheduleEdit();
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(calls[1]).toEqual({ op: 'edit', id: 1, text: 'Hello, world', final: false });
+  });
+
+  it('throttles edits: many schedules inside one window produce one flush', async () => {
+    const { sink, calls } = makeSink();
+    let text = '';
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => text });
+
+    for (const t of ['a', 'ab', 'abc', 'abcd']) {
+      text = t;
+      pump.scheduleEdit();
+      await vi.advanceTimersByTimeAsync(100);
+    }
+    await vi.advanceTimersByTimeAsync(1000);
+    // One send carrying the newest text at flush time — not four.
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.text).toBe('abcd');
+  });
+
+  it('skips a flush whose frame is unchanged', async () => {
+    const { sink, calls } = makeSink();
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => 'same' });
+
+    await pump.flush(false);
+    await pump.flush(false);
+    await pump.flush(true);
+    expect(calls).toHaveLength(1);
+  });
+
+  it('alwaysFlushFinal delivers the final frame to the sink even when unchanged', async () => {
+    const { sink, calls } = makeSink();
+    const pump = new FramePump<number>({
+      sink,
+      editFrameMs: 1000,
+      frame: () => 'same',
+      alwaysFlushFinal: true,
+    });
+
+    await pump.flush(false);
+    await pump.flush(true);
+    expect(calls).toEqual([
+      { op: 'send', text: 'same', final: false },
+      { op: 'edit', id: 1, text: 'same', final: true },
+    ]);
+  });
+
+  it('posts emptyFinalText when a final flush finds no content and nothing was sent', async () => {
+    const { sink, calls } = makeSink();
+    const pump = new FramePump<number>({
+      sink,
+      editFrameMs: 1000,
+      frame: () => '',
+      emptyFinalText: '(no output)',
+    });
+
+    await pump.flush(false); // mid-stream empty → nothing
+    expect(calls).toHaveLength(0);
+    await pump.flush(true);
+    expect(calls).toEqual([{ op: 'send', text: '(no output)', final: true }]);
+  });
+
+  it('does not post emptyFinalText when a message was already sent', async () => {
+    const { sink, calls } = makeSink();
+    let text = 'content';
+    const pump = new FramePump<number>({
+      sink,
+      editFrameMs: 1000,
+      frame: () => text,
+      emptyFinalText: '(no output)',
+    });
+
+    await pump.flush(false);
+    text = '';
+    await pump.flush(true);
+    expect(calls).toEqual([{ op: 'send', text: 'content', final: false }]);
+  });
+
+  it('retries as a fresh send when the first send failed (id stays null)', async () => {
+    const failing = makeSink({ failSends: true });
+    let text = 'one';
+    const pump = new FramePump<number>({
+      sink: failing.sink,
+      editFrameMs: 1000,
+      frame: () => text,
+    });
+    await pump.flush(false);
+    expect(pump.messageId).toBeNull();
+
+    text = 'two';
+    await pump.flush(false);
+    // Still a send (never an edit on a null id).
+    expect(failing.calls.map((c) => c.op)).toEqual(['send', 'send']);
+  });
+
+  it('a final flush waits out an in-flight send instead of being dropped', async () => {
+    const calls: SinkCall[] = [];
+    let text = 'streamed';
+    let release: (() => void) | null = null;
+    const gate = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const sink: FrameSink<number> = {
+      async send(t, final) {
+        calls.push({ op: 'send', text: t, final });
+        await gate; // hold the first send in flight
+        return 1;
+      },
+      async edit(id, t, final) {
+        calls.push({ op: 'edit', id, text: t, final });
+      },
+    };
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => text });
+
+    const first = pump.flush(false); // in flight, parked on the gate
+    text = 'streamed + final';
+    const final = pump.flush(true); // must wait, then deliver the final text
+    release?.();
+    await first;
+    await final;
+
+    expect(calls).toEqual([
+      { op: 'send', text: 'streamed', final: false },
+      { op: 'edit', id: 1, text: 'streamed + final', final: true },
+    ]);
+  });
+
+  it('re-arms the timer when content advances during a send', async () => {
+    const calls: SinkCall[] = [];
+    let text = 'v1';
+    let sends = 0;
+    const sink: FrameSink<number> = {
+      async send(t, final) {
+        calls.push({ op: 'send', text: t, final });
+        sends += 1;
+        if (sends === 1) text = 'v2'; // new content lands mid-send
+        return sends;
+      },
+      async edit(id, t, final) {
+        calls.push({ op: 'edit', id, text: t, final });
+      },
+    };
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => text });
+
+    await pump.flush(false);
+    // The pump noticed the newer frame and re-armed its own timer.
+    await vi.advanceTimersByTimeAsync(1000);
+    expect(calls).toEqual([
+      { op: 'send', text: 'v1', final: false },
+      { op: 'edit', id: 1, text: 'v2', final: false },
+    ]);
+  });
+
+  it('dispose cancels a pending edit', async () => {
+    const { sink, calls } = makeSink();
+    const pump = new FramePump<number>({ sink, editFrameMs: 1000, frame: () => 'x' });
+    pump.scheduleEdit();
+    pump.dispose();
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(calls).toHaveLength(0);
+  });
+});

package/src/frame-pump.ts

@@ -0,0 +1,154 @@
+/**
+ * Throttled "send once, then edit one message" streaming loop — the shared core
+ * behind the Telegram and Slack frame pumps. The channel feeds it "something
+ * changed" signals (`scheduleEdit`); the pump pulls the current frame text from
+ * the `frame` callback at flush time and drives a tiny messenger-agnostic
+ * {@link FrameSink} (`send` a new message, `edit` an existing one).
+ *
+ * Lifecycle per turn:
+ *   1. construct with a sink bound to the turn's target (chat / thread).
+ *   2. `scheduleEdit()` whenever the rendered snapshot changes → debounced
+ *      `flush(false)` after `editFrameMs`.
+ *   3. `flush(true)` on turn completion drains the final snapshot (and posts
+ *      `emptyFinalText` when the turn rendered nothing at all).
+ *   4. `dispose()` clears the timer.
+ *
+ * Messenger-specific concerns stay in the sink: Telegram's HTML parse-mode
+ * fallback and 4096-char message splitting, Slack's `chat.postMessage` /
+ * `chat.update` calls. The `final` flag is forwarded so a sink can perform
+ * final-only work (Telegram sends split-overflow tails only on the last frame).
+ */
+
+/** Messenger adapter the pump drives. Implementations should swallow their own
+ *  transport errors (log + return null / resolve) — a failed frame must never
+ *  abort the turn. */
+export interface FrameSink<Id> {
+  /** Send a NEW message; returns its id, or null when the send failed. */
+  send(text: string, final: boolean): Promise<Id | null>;
+  /** Edit a previously sent message in place. */
+  edit(id: Id, text: string, final: boolean): Promise<void>;
+}
+
+export interface FramePumpOptions<Id> {
+  readonly sink: FrameSink<Id>;
+  /** Debounce window for streaming edits (typically ~1s). */
+  readonly editFrameMs: number;
+  /**
+   * Produce the current frame text. Called at flush time (pull model) so the
+   * flushed frame always reflects the newest renderer state; `final` lets a
+   * renderer emit a different last frame (e.g. Telegram collapses its activity
+   * trace only on the final flush). An empty string means "nothing to show".
+   */
+  readonly frame: (final: boolean) => string;
+  /**
+   * Sent when the FINAL flush finds no content and no message was ever sent,
+   * so the user isn't left staring at a placeholder-less turn. Omit to skip.
+   */
+  readonly emptyFinalText?: string;
+  /**
+   * Deliver the final frame to the sink even when its text is identical to the
+   * last sent frame. Channels whose sink does final-only work that must not be
+   * skipped (Telegram's split tails) set this; channels where the final frame
+   * is a plain re-send (Slack) leave it off and save the no-op API call.
+   */
+  readonly alwaysFlushFinal?: boolean;
+}
+
+export class FramePump<Id> {
+  private readonly opts: FramePumpOptions<Id>;
+  private id: Id | null = null;
+  private lastSent = '';
+  private editTimer: ReturnType<typeof setTimeout> | null = null;
+  /** In-flight send/edit, so timer + flush never overlap (single-flight). */
+  private inflight: Promise<void> | null = null;
+
+  constructor(opts: FramePumpOptions<Id>) {
+    this.opts = opts;
+  }
+
+  /** The id of the streamed message once sent (null until the first frame lands). */
+  get messageId(): Id | null {
+    return this.id;
+  }
+
+  /** Debounced "content changed" signal → `flush(false)` after `editFrameMs`. */
+  scheduleEdit(): void {
+    if (this.editTimer || this.inflight) return;
+    this.editTimer = setTimeout(() => {
+      this.editTimer = null;
+      void this.flush(false);
+    }, this.opts.editFrameMs);
+  }
+
+  /**
+   * Drain the current frame to the sink. The first non-empty frame `send`s a
+   * new message; every later frame `edit`s it in place. A `final` flush is
+   * never dropped: if a send is in flight it waits for it, and it guarantees
+   * at least one message (via `emptyFinalText`) when the turn rendered nothing.
+   */
+  async flush(final: boolean): Promise<void> {
+    this.cancelTimer();
+    if (this.inflight) {
+      if (!final) {
+        // A send is running; re-arm so the newest text lands after it.
+        if (this.opts.frame(false) !== this.lastSent) this.scheduleEdit();
+        return;
+      }
+      // Final flushes must not be lost — wait out the in-flight send.
+      await this.inflight;
+    }
+    const text = this.opts.frame(final);
+    if (!text) {
+      if (final && this.id == null && this.opts.emptyFinalText) {
+        const placeholder = this.opts.emptyFinalText;
+        await this.track(async () => {
+          const sent = await this.opts.sink.send(placeholder, final);
+          if (sent != null) this.id = sent;
+        });
+      }
+      return;
+    }
+    if (text === this.lastSent && !(final && this.opts.alwaysFlushFinal)) return;
+    await this.track(async () => {
+      if (this.id == null) {
+        const sent = await this.opts.sink.send(text, final);
+        if (sent != null) this.id = sent;
+      } else {
+        await this.opts.sink.edit(this.id, text, final);
+      }
+      this.lastSent = text;
+    });
+    // Content may have advanced while the send was in flight.
+    if (final) {
+      if (this.opts.frame(true) !== this.lastSent) await this.flush(true);
+    } else if (this.opts.frame(false) !== this.lastSent) {
+      this.scheduleEdit();
+    }
+  }
+
+  dispose(): void {
+    this.cancelTimer();
+  }
+
+  private async track(work: () => Promise<void>): Promise<void> {
+    const run = work();
+    // Waiters must never observe a rejection here; errors propagate to the
+    // caller of `flush` below (sinks are expected to swallow transport errors).
+    this.inflight = run.then(
+      () => undefined,
+      () => undefined,
+    );
+    try {
+      await run;
+    } finally {
+      this.inflight = null;
+    }
+  }
+
+  private cancelTimer(): void {
+    if (this.editTimer) {
+      clearTimeout(this.editTimer);
+      this.editTimer = null;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,66 @@
+/**
+ * @moxxy/channel-kit — shared machinery for building moxxy messaging channels.
+ *
+ * Extracted from the Telegram and Slack channel plugins so new channels
+ * (Discord, WhatsApp, Signal, ...) are thin adapters: messenger-specific quirks
+ * (formatting, transport error handling, signature schemes, pairing wording)
+ * stay in each plugin; the load-bearing loop mechanics live here.
+ */
+
+export { FramePump, type FrameSink, type FramePumpOptions } from './frame-pump.js';
+export {
+  TurnCoordinator,
+  driveTurn,
+  subscribeTurn,
+  type DriveTurnOptions,
+  type TurnCoordinatorOptions,
+  type TurnEventSource,
+  type TurnLease,
+  type TurnSession,
+} from './turn.js';
+export { PlainTurnRenderer } from './plain-turn-renderer.js';
+export {
+  clearHostCodePairing,
+  createHostCodeState,
+  greetPeer,
+  isPeerAuthorized,
+  openHostCodeWindow,
+  submitPeerCode,
+  type HostCodeAction,
+  type HostCodeDecision,
+  type HostCodePhase,
+  type HostCodeState,
+} from './pairing/host-code.js';
+export { TofuPairingWindow, type TofuPairingWindowOptions } from './pairing/tofu.js';
+export { resolveSecret, type SecretReader, type SecretSpec } from './secrets.js';
+export {
+  createAuditedAllowListResolver,
+  type AuditedAllowListOptions,
+} from './permission.js';
+export {
+  IngestHttpServer,
+  respondJson,
+  type IngestHttpServerHandle,
+  type IngestHttpServerOptions,
+  type IngestLogger,
+  type IngestVerdict,
+} from './ingest/http-server.js';
+export { DeliveryDedupeCache } from './ingest/dedupe.js';
+export {
+  audioExtForMime,
+  deliverVoiceReply,
+  ensureOggOpus,
+  resolveVoiceToggle,
+  synthesizeReply,
+  toSpeech,
+  type DeliverVoiceReplyOptions,
+  type EnsureOggOpusOptions,
+  type EnsureOggOpusResult,
+  type SynthesizeReplyOptions,
+  type SynthesizeReplyResult,
+  type SynthesizerSource,
+  type VoiceReplyOutcome,
+  type VoiceReplySink,
+  type VoiceToggleInput,
+  type VoiceToggleResult,
+} from './voice-reply.js';

package/src/ingest/dedupe.test.ts

@@ -0,0 +1,58 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { DeliveryDedupeCache } from './dedupe.js';
+
+describe('DeliveryDedupeCache', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('admits a new event_id once, then rejects the repeat', () => {
+    const c = new DeliveryDedupeCache();
+    expect(c.check('Ev123')).toBe(true);
+    expect(c.check('Ev123')).toBe(false);
+    expect(c.check('Ev123')).toBe(false);
+  });
+
+  it('distinct event ids are independent', () => {
+    const c = new DeliveryDedupeCache();
+    expect(c.check('Ev1')).toBe(true);
+    expect(c.check('Ev2')).toBe(true);
+    expect(c.check('Ev1')).toBe(false);
+  });
+
+  it('re-admits an event after its TTL has elapsed', () => {
+    const c = new DeliveryDedupeCache({ ttlMs: 1000 });
+    expect(c.check('k')).toBe(true);
+    expect(c.check('k')).toBe(false);
+    vi.setSystemTime(1000);
+    expect(c.check('k')).toBe(false);
+    vi.setSystemTime(2001);
+    expect(c.check('k')).toBe(true);
+  });
+
+  it('evicts the oldest entry once maxEntries is exceeded', () => {
+    const c = new DeliveryDedupeCache({ maxEntries: 2 });
+    expect(c.check('a')).toBe(true);
+    vi.setSystemTime(1);
+    expect(c.check('b')).toBe(true);
+    expect(c.size()).toBe(2);
+    vi.setSystemTime(2);
+    expect(c.check('c')).toBe(true); // evicts 'a'
+    expect(c.size()).toBe(2);
+    expect(c.check('a')).toBe(true); // 'a' was dropped → new again
+  });
+
+  it('clear() empties the cache', () => {
+    const c = new DeliveryDedupeCache();
+    c.check('a');
+    c.check('b');
+    expect(c.size()).toBe(2);
+    c.clear();
+    expect(c.size()).toBe(0);
+    expect(c.check('a')).toBe(true);
+  });
+});

package/src/ingest/dedupe.ts

@@ -0,0 +1,66 @@
+/**
+ * In-memory LRU for inbound-delivery idempotency. Webhook providers retry
+ * deliveries and the same event id may arrive more than once, so channels
+ * dedupe by delivery id for a bounded window (Slack: `event_id` +
+ * `X-Slack-Retry-Num`; same at-least-once pattern as `@moxxy/plugin-webhooks`).
+ *
+ * Not persistent — a restart resets the cache, which is acceptable: worst case
+ * the agent processes one event twice immediately after restart, which is rare
+ * and self-limiting.
+ */
+export class DeliveryDedupeCache {
+  private readonly seen = new Map<string, number>();
+  private readonly maxEntries: number;
+  private readonly ttlMs: number;
+  /** Sweep TTL-expired entries at most once per this interval. The LRU overflow
+   *  cap already bounds memory, so the TTL sweep need not run on every check —
+   *  amortizing it keeps the pre-ACK path O(1) under retry storms. */
+  private readonly sweepEveryMs: number;
+  private lastSweepMs = -Infinity;
+
+  constructor(opts: { maxEntries?: number; ttlMs?: number; sweepEveryMs?: number } = {}) {
+    this.maxEntries = opts.maxEntries ?? 4096;
+    this.ttlMs = opts.ttlMs ?? 24 * 60 * 60 * 1000;
+    this.sweepEveryMs = opts.sweepEveryMs ?? Math.min(this.ttlMs, 15_000);
+  }
+
+  /** Returns true if this is a new key (now recorded); false if a duplicate. */
+  check(key: string): boolean {
+    const now = Date.now();
+    this.evictExpired(now);
+    const seenAt = this.seen.get(key);
+    // Honor the TTL on the looked-up key directly so amortizing the full sweep
+    // never makes an already-expired key read as a live duplicate.
+    if (seenAt !== undefined && seenAt >= now - this.ttlMs) {
+      this.seen.delete(key);
+      this.seen.set(key, now);
+      return false;
+    }
+    if (seenAt !== undefined) this.seen.delete(key);
+    this.seen.set(key, now);
+    if (this.seen.size > this.maxEntries) {
+      const first = this.seen.keys().next();
+      if (!first.done) this.seen.delete(first.value);
+    }
+    return true;
+  }
+
+  size(): number {
+    return this.seen.size;
+  }
+
+  clear(): void {
+    this.seen.clear();
+    this.lastSweepMs = -Infinity;
+  }
+
+  private evictExpired(now: number): void {
+    if (now - this.lastSweepMs < this.sweepEveryMs) return;
+    this.lastSweepMs = now;
+    const cutoff = now - this.ttlMs;
+    for (const [k, ts] of this.seen) {
+      if (ts >= cutoff) break;
+      this.seen.delete(k);
+    }
+  }
+}

package/src/ingest/http-server.test.ts

@@ -0,0 +1,120 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { IngestHttpServer, respondJson } from './http-server.js';
+
+const EVENTS = '/test/events';
+const HEALTH = '/test/health';
+
+interface Harness {
+  server: IngestHttpServer;
+  base: string;
+  received: Array<{ body: string; headers: Record<string, unknown> }>;
+  stop(): Promise<void>;
+}
+
+async function makeServer(
+  over: Partial<{
+    verifyOk: boolean;
+    maxBodyBytes: number;
+    handleVerified: (raw: Buffer, req: IncomingMessage, res: ServerResponse) => Promise<void>;
+  }> = {},
+): Promise<Harness> {
+  const received: Harness['received'] = [];
+  const server = new IngestHttpServer({
+    eventsPath: EVENTS,
+    healthPath: HEALTH,
+    healthBody: () => ({ status: 'ok', listener: 'test' }),
+    label: 'test',
+    ...(over.maxBodyBytes !== undefined ? { maxBodyBytes: over.maxBodyBytes } : {}),
+    verify: () =>
+      (over.verifyOk ?? true) ? { ok: true } : { ok: false, reason: 'bad signature' },
+    handleVerified:
+      over.handleVerified ??
+      (async (raw, req, res) => {
+        received.push({ body: raw.toString('utf8'), headers: { ...req.headers } });
+        respondJson(res, 200, { status: 'ok' });
+      }),
+  });
+  const bound = await server.start();
+  return {
+    server,
+    base: `http://${bound.host}:${bound.port}`,
+    received,
+    stop: () => server.stop(),
+  };
+}
+
+describe('IngestHttpServer', () => {
+  let h: Harness;
+  afterEach(async () => {
+    await h?.stop();
+  });
+
+  it('serves the health probe', async () => {
+    h = await makeServer();
+    const res = await fetch(`${h.base}${HEALTH}`);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ status: 'ok', listener: 'test' });
+  });
+
+  it('404s anything that is not POST on the events path', async () => {
+    h = await makeServer();
+    expect((await fetch(`${h.base}${EVENTS}`, { method: 'GET' })).status).toBe(404);
+    expect((await fetch(`${h.base}/other`, { method: 'POST', body: '{}' })).status).toBe(404);
+  });
+
+  it('hands the verified raw body to handleVerified', async () => {
+    h = await makeServer();
+    const body = JSON.stringify({ hello: 'world' });
+    const res = await fetch(`${h.base}${EVENTS}`, { method: 'POST', body });
+    expect(res.status).toBe(200);
+    expect(h.received).toHaveLength(1);
+    expect(h.received[0]?.body).toBe(body);
+  });
+
+  it('401s when verification fails, before handleVerified', async () => {
+    h = await makeServer({ verifyOk: false });
+    const res = await fetch(`${h.base}${EVENTS}`, { method: 'POST', body: '{}' });
+    expect(res.status).toBe(401);
+    expect(await res.json()).toEqual({ error: 'verification_failed' });
+    expect(h.received).toHaveLength(0);
+  });
+
+  it('rejects an oversized body without reaching handleVerified', async () => {
+    h = await makeServer({ maxBodyBytes: 16 });
+    // readRequestBody may destroy the socket at the cap, so accept 413 or a
+    // dropped connection — what MUST hold is that the handler never ran.
+    let status = 0;
+    try {
+      const res = await fetch(`${h.base}${EVENTS}`, {
+        method: 'POST',
+        body: 'x'.repeat(500),
+      });
+      status = res.status;
+    } catch {
+      status = -1;
+    }
+    expect([413, -1]).toContain(status);
+    expect(h.received).toHaveLength(0);
+  });
+
+  it('a throwing handler becomes a 500, never an uncaught exception', async () => {
+    h = await makeServer({
+      handleVerified: async () => {
+        throw new Error('boom');
+      },
+    });
+    const res = await fetch(`${h.base}${EVENTS}`, { method: 'POST', body: '{}' });
+    expect(res.status).toBe(500);
+    expect(await res.json()).toEqual({ error: 'internal' });
+  });
+
+  it('start is idempotent and stop unbinds', async () => {
+    h = await makeServer();
+    const again = await h.server.start();
+    expect(again.port).toBe(h.server.port);
+    await h.stop();
+    await expect(fetch(`${h.base}${HEALTH}`)).rejects.toThrow();
+    h = { stop: async () => {} } as Harness;
+  });
+});