@ccmsg/cli 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",

package/src/daemon/supervise.ts

@@ -45,6 +45,9 @@ export interface Backoff {
 
 export const BACKOFF: Backoff = { minMs: 500, maxMs: 30_000, steadyMs: 60_000 };
 
+/** The time each cooperative stop stage gets before the supervisor escalates. */
+export const STOP_TIMEOUT_MS = 10_000;
+
 export interface SuperviseOptions {
   readonly env?: Env;
   readonly spawn?: SpawnInstance;
@@ -54,6 +57,8 @@ export interface SuperviseOptions {
   /** How long a start waits for the child to be serving before it is reported
    * as having failed. */
   readonly startTimeoutMs?: number;
+  /** How long each graceful and SIGTERM stop stage may hold shutdown. */
+  readonly stopTimeoutMs?: number;
 }
 
 /** One config home the supervisor looks after, and how it is doing.
@@ -98,6 +103,7 @@ export class Supervisor {
   readonly #backoff: Backoff;
   readonly #log: (line: Record<string, unknown>) => void;
   readonly #startTimeoutMs: number;
+  readonly #stopTimeoutMs: number;
   readonly #units = new Map<string, Supervised>();
   readonly #waits = new Set<() => void>();
   #listener: ReturnType<typeof Bun.listen> | undefined;
@@ -110,6 +116,7 @@ export class Supervisor {
     this.#spawn = options.spawn ?? spawnInstance;
     this.#backoff = options.backoff ?? BACKOFF;
     this.#startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
+    this.#stopTimeoutMs = options.stopTimeoutMs ?? STOP_TIMEOUT_MS;
     this.#log = options.log ?? ((line) => process.stderr.write(`${JSON.stringify(line)}\n`));
     for (const target of registered(this.#env)) this.#units.set(target.dir, new Supervised(target));
   }
@@ -278,12 +285,7 @@ export class Supervisor {
     // asked for rather than one to recover from.
     unit.wanted = false;
     for (const cancel of new Set(this.#waits)) cancel();
-    try {
-      await askToStop(unit.target);
-    } catch {
-      child.kill("SIGTERM");
-    }
-    await child.exited;
+    await this.#stopChild(unit, child);
     await unit.loop;
     return { dir, stopped: true };
   }
@@ -394,27 +396,70 @@ export class Supervisor {
     });
   }
 
-  /** Stop every child, stop restarting them, and give up the socket.
-   *
-   * The socket goes first, so a command arriving mid-shutdown is told there is
-   * no supervisor rather than being answered by one that is leaving. */
+  async #stopChild(unit: Supervised, child: Child): Promise<void> {
+    const within = async (work: Promise<unknown>): Promise<boolean> => {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const deadline = new Promise<false>((resolve) => {
+        timer = setTimeout(() => resolve(false), this.#stopTimeoutMs);
+      });
+      try {
+        return await Promise.race([
+          work.then(
+            () => true,
+            () => false,
+          ),
+          deadline,
+        ]);
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    // Each stage is said out loud with how long the one before it took. A child
+    // that will not leave is a thing that happens on a machine nobody is
+    // watching, and what stage it was at is the whole of what can be known
+    // about it afterwards.
+    const startedAt = Date.now();
+    const say = (stage: string) => {
+      this.#log({
+        event: "stopping",
+        dir: unit.target.dir,
+        pid: child.pid,
+        stage,
+        in_ms: Date.now() - startedAt,
+      });
+    };
+
+    say("asked");
+    if (await within(askToStop(unit.target).then(() => child.exited))) {
+      say("exited");
+      return;
+    }
+    say("sigterm");
+    child.kill("SIGTERM");
+    if (await within(child.exited)) {
+      say("exited");
+      return;
+    }
+    say("sigkill");
+    child.kill("SIGKILL");
+    await child.exited;
+    say("exited");
+  }
+
+  /** Stop every child, stop restarting them, and give up the socket. */
   async stop(): Promise<void> {
     this.#leaving = true;
-    this.#listener?.stop(true);
-    this.#listener = undefined;
     for (const cancel of new Set(this.#waits)) cancel();
     await Promise.all(
       [...this.#units.values()].map(async (unit) => {
         const child = unit.child;
         if (child === undefined) return;
-        try {
-          await askToStop(unit.target);
-        } catch {
-          child.kill("SIGTERM");
-        }
-        await child.exited;
+        await this.#stopChild(unit, child);
       }),
     );
+    this.#listener?.stop(true);
+    this.#listener = undefined;
     this.#left?.();
     await this.#ran;
   }

package/src/instance/instance.ts

@@ -522,18 +522,14 @@ export class Instance {
       ...(this.#mesh === undefined ? {} : { cluster: this.#mesh }),
       inbox,
       direct: this.#direct,
-      publish: (topic, data, instance, to) => {
-        this.#topics.publish(topic, data, instance, to);
-      },
+      publish: (topic, data, instance, to) => this.#topics.publish(topic, data, instance, to),
       listeners: (topic, to) => this.#topics.subscriberCount(topic, to),
     });
 
     this.#notify = new Notify({
       self: this.self,
       label: (sid) => sessionLabel(this.#sessions, sid),
-      publish: (topic, data, instance) => {
-        this.#topics.publish(topic, data, instance);
-      },
+      publish: (topic, data, instance) => this.#topics.publish(topic, data, instance),
     });
 
     this.#topics.attach("peers", this.#sessions);
@@ -941,15 +937,25 @@ export class Instance {
     // they change rather than at exit, so there is nothing held back to flush;
     // the log's writer is synchronous for the same reason (§3.6).
     this.log.write("stopping", { instance: this.self });
-    // 5. let the resources go, the unix socket last. The pid and the lock go
-    // before it, because a client reads a refusing socket as this instance
-    // having finished leaving and a successor may claim what it sees free.
-    remove(this.paths.pidFile);
-    this.lock.release();
-    // Closing takes the path this process bound, and only that one: the stable
-    // address is a symlink nothing here touches, because a successor may have
-    // already pointed it at itself (§8.5).
-    await this.#transport.close();
+    // 5. let the resources go, the unix socket last. Closing takes the path
+    // this process bound, and only that one: the stable address is a symlink
+    // nothing here touches, because a successor may have already pointed it at
+    // itself (§8.5).
+    try {
+      await this.#transport.close();
+    } catch (cause) {
+      // A listener that could not be closed is worth saying, and is not worth
+      // holding the pid and the lock over: this process is leaving either way,
+      // and keeping them would leave a successor unable to start against a
+      // config home nothing is serving.
+      this.log.write("listener close failed", { instance: this.self, cause: String(cause) });
+    } finally {
+      // The pid and lock are the observable proof that this process is still
+      // leaving. Released only after every listener has finished closing, so a
+      // client cannot mistake an unreachable socket for a completed stop.
+      remove(this.paths.pidFile);
+      this.lock.release();
+    }
   }
 }
 

package/src/messaging/delivery.ts

@@ -21,7 +21,7 @@ import {
   OpError,
   type Requester,
 } from "../dispatch/index.ts";
-import type { TopicValue, UpstreamResource } from "../topics/index.ts";
+import type { PublishOutcome, TopicValue, UpstreamResource } from "../topics/index.ts";
 import type { DirectRoute } from "./direct.ts";
 import type { Inbox } from "./inbox.ts";
 
@@ -71,7 +71,7 @@ export interface DeliveryDeps {
   readonly direct: DirectRoute;
   /** The one way a value reaches subscribers (§6.1), narrowed to the session a
    * message is for. */
-  readonly publish: (topic: string, data: unknown, instance: InstanceId, to: Sid) => void;
+  readonly publish: (topic: string, data: unknown, instance: InstanceId, to: Sid) => PublishOutcome;
   /** How many of that session's connections are listening on `inbox`. */
   readonly listeners: (topic: string, to: Sid) => number;
 }
@@ -128,8 +128,14 @@ export class Delivery implements UpstreamResource {
     }
 
     if (this.deps.listeners(INBOX, to) > 0) {
-      this.deps.publish(INBOX, [message], this.deps.self, to);
-      return { delivered: true };
+      if (this.deps.publish(INBOX, [message], this.deps.self, to) === "ok") {
+        return { delivered: true };
+      }
+      // The session is listening but is behind on what it has already been
+      // offered, which is the same standing as route (a) turning the message
+      // away: it waits in the inbox and is offered again (§4.4).
+      this.deps.inbox.hold(to, message);
+      return { delivered: false, reason: "throttled" };
     }
 
     const { evicted } = this.deps.inbox.hold(to, message);

package/src/messaging/notify.ts

@@ -11,7 +11,7 @@ import type {
   Timestamp,
 } from "@ccmsg/protocol";
 import { type HandlerInput, OpError } from "../dispatch/index.ts";
-import type { TopicValue, UpstreamResource } from "../topics/index.ts";
+import type { PublishOutcome, TopicValue, UpstreamResource } from "../topics/index.ts";
 
 /** The one topic a notification reaches a watcher on. */
 const NOTIFY = "notify";
@@ -23,7 +23,7 @@ export interface NotifyDeps {
   readonly label: (sid: Sid) => string;
   /** The one way a value reaches subscribers (§6.1). No `to`: a notification is
    * for whoever is watching, not for one session. */
-  readonly publish: (topic: string, data: unknown, instance: InstanceId) => void;
+  readonly publish: (topic: string, data: unknown, instance: InstanceId) => PublishOutcome;
 }
 
 /** The `notify` topic and the three ops that speak on it.
@@ -99,7 +99,16 @@ export class Notify implements UpstreamResource {
       text,
       sent_at: now,
     };
-    this.deps.publish(NOTIFY, notification, this.deps.self);
+    // A notification is an occurrence, so nothing folds it away and a watcher
+    // that cannot keep up is what stops it. The caller hears that rather than
+    // the notification going nowhere: it is the one that decides whether to
+    // raise another (§6.4).
+    if (this.deps.publish(NOTIFY, notification, this.deps.self) === "rate_limited") {
+      throw new OpError(
+        "internal_error",
+        "a watcher is behind on this topic; the notification was not taken",
+      );
+    }
     return now;
   }
 

package/src/service/service.ts

@@ -171,20 +171,62 @@ function refuse(command: readonly string[], answer: RunResult): never {
   );
 }
 
+/** How long the supervisor gets to leave after being asked to, before the init
+ * system is told to kill it.
+ *
+ * The same budget the supervisor gives each of its own children, because that
+ * is what it spends: a supervisor that is going to leave has finished leaving
+ * by the time its last child has. */
+export const STOP_DEADLINE_MS = 10_000;
+
+/** How often the init system is asked again while waiting for a departure. */
+const DEPARTURE_POLL_MS = 100;
+
+/** Whether `gone` holds, waited for up to the deadline.
+ *
+ * Asked again rather than awaited: the supervisor belongs to the init system
+ * and not to this process, so there is no exit to wait on and the only account
+ * of whether it is still there is one that has to be fetched. */
+async function departed(gone: () => Promise<boolean>, deadlineMs: number): Promise<boolean> {
+  const end = Date.now() + deadlineMs;
+  for (;;) {
+    if (await gone()) return true;
+    const left = end - Date.now();
+    if (left <= 0) return false;
+    await Bun.sleep(Math.min(DEPARTURE_POLL_MS, left));
+  }
+}
+
+/** Whether the process that held `pid` is still there, asked of the kernel
+ * rather than of the init system.
+ *
+ * `kill -0` and not a report, because a unit that has been booted out is one
+ * launchd no longer says anything about — including whether the process it was
+ * running has actually gone. It goes through `Run` for the reason everything
+ * else here does: a test drives it without a process on this machine being
+ * signalled. */
+async function alive(pid: number, run: Run): Promise<boolean> {
+  return (await run(["kill", "-0", String(pid)])).code === 0;
+}
+
 export class LaunchdService implements Service {
   readonly kind = "launchd" as const;
   readonly unitFile: string;
   readonly #label: string;
   readonly #env: Env;
   readonly #domain: string;
+  readonly #stopDeadlineMs: number;
 
   /** The label is a parameter for `Run`'s reason: a test that drives this
    * machine's real launchd has to do it under a name that is not the one the
    * machine's own supervisor is registered under. Nothing in ccmsg passes it —
-   * `serviceFor` is where the name is settled. */
-  constructor(env: Env, label: string = LAUNCHD_LABEL) {
+   * `serviceFor` is where the name is settled. The deadline is a parameter for
+   * the same reason: a test drives the escalation without waiting out ten
+   * seconds of it. */
+  constructor(env: Env, label: string = LAUNCHD_LABEL, stopDeadlineMs = STOP_DEADLINE_MS) {
     this.#env = env;
     this.#label = label;
+    this.#stopDeadlineMs = stopDeadlineMs;
     const home = env["HOME"] ?? homedir();
     this.unitFile = join(home, "Library", "LaunchAgents", `${label}.plist`);
     this.#domain = `gui/${String(process.getuid?.() ?? 0)}`;
@@ -261,8 +303,33 @@ export class LaunchdService implements Service {
     return await this.state(run);
   }
 
+  /** Take the unit out of launchd, and stay until the supervisor has gone.
+   *
+   * `bootout` rather than a signal, because `KeepAlive` means a supervisor that
+   * is signalled is one launchd starts again: what the person asked for is a
+   * supervisor that stays stopped, which is systemd's `stop` and launchd's
+   * `bootout`. The file stays where it is — a unit launchd is not holding is
+   * what `start` already knows how to bootstrap, and taking the file away as
+   * well is `unregister`.
+   *
+   * The answer waits for the pid rather than being read off the command,
+   * because the moment the command returns is the moment the supervisor starts
+   * leaving and not the one it finishes at: a supervisor wedged in its own
+   * shutdown would otherwise be reported as gone by a `service stop` that had
+   * only asked. One that will not go inside the deadline is killed. */
   async stop(run: Run): Promise<ServiceState> {
-    await run(["launchctl", "kill", "SIGTERM", `${this.#domain}/${this.#label}`]);
+    const before = await this.#report(run);
+    // A refusal is launchd saying it is not holding this label, which is the
+    // state being asked for; `state` below is what reports otherwise.
+    await run(["launchctl", "bootout", `${this.#domain}/${this.#label}`]);
+    const held = before.service?.pid ?? null;
+    if (held !== null) {
+      const gone = async () => !(await alive(held, run));
+      if (!(await departed(gone, this.#stopDeadlineMs))) {
+        await run(["kill", "-KILL", String(held)]);
+        await departed(gone, this.#stopDeadlineMs);
+      }
+    }
     return await this.state(run);
   }
 
@@ -306,9 +373,11 @@ class SystemdService implements Service {
   readonly kind = "systemd" as const;
   readonly unitFile: string;
   readonly #env: Env;
+  readonly #stopDeadlineMs: number;
 
-  constructor(env: Env) {
+  constructor(env: Env, stopDeadlineMs = STOP_DEADLINE_MS) {
     this.#env = env;
+    this.#stopDeadlineMs = stopDeadlineMs;
     const home = env["HOME"] ?? homedir();
     const config = env["XDG_CONFIG_HOME"] ?? join(home, ".config");
     this.unitFile = join(config, "systemd", "user", SYSTEMD_UNIT);
@@ -374,8 +443,26 @@ class SystemdService implements Service {
     return await this.state(run);
   }
 
+  /** `LaunchdService.stop`'s reasoning, in systemd's vocabulary.
+   *
+   * `stop` here holds until the unit is inactive on its own, so the wait below
+   * usually settles on its first question; it is asked anyway because what the
+   * caller is promised is the departure, not the command having returned, and
+   * a `stop` that gave up on its own `TimeoutStopSec` returns having left the
+   * process behind. */
   async stop(run: Run): Promise<ServiceState> {
+    const before = await this.#report(run);
     await run(["systemctl", "--user", "stop", SYSTEMD_UNIT]);
+    const held = before.service?.pid ?? null;
+    if (held !== null) {
+      // The unit is still loaded here, so systemd is still the one that knows
+      // what became of the process it started.
+      const gone = async () => (await this.#report(run)).service?.pid !== held;
+      if (!(await departed(gone, this.#stopDeadlineMs))) {
+        await run(["systemctl", "--user", "kill", "--signal=SIGKILL", SYSTEMD_UNIT]);
+        await departed(gone, this.#stopDeadlineMs);
+      }
+    }
     return await this.state(run);
   }
 

package/src/topics/egress.ts

@@ -0,0 +1,162 @@
+import type { Requester } from "../dispatch/index.ts";
+
+/** How long one terminal's frames are gathered before they go out.
+ *
+ * The value bounds two things at once. Towards the reader: a person watching a
+ * list cannot see a change arrive sooner than the display draws it, so frames
+ * closer together than a few display frames are spent on nothing, while a wait
+ * long enough to be read as lag starts around a quarter of a second. Towards
+ * the cluster: a relayed frame waits once per hop, so the delay a subscriber
+ * sees is this value times the hops between it and the instance that produced
+ * the value — at 100 ms a two-hop cluster still answers inside the window a
+ * person reads as immediate, which a longer period would leave.
+ *
+ * It is not a poll. Nothing is looked at when the period elapses: the timer is
+ * armed only by a frame that has to wait, and an idle terminal has none. */
+export const FLUSH_PERIOD_MS = 100;
+
+/** How many frames that cannot be folded one terminal may hold at once.
+ *
+ * Folded frames need no bound — a topic that replaces its value keeps one entry
+ * however often it is stated — so this bounds the occurrences and the deltas,
+ * the frames that mean something twice if they arrive twice. At one flush every
+ * `FLUSH_PERIOD_MS` a terminal that keeps up drains this many every period, so
+ * reaching the limit means the producer has been outrunning the reader by more
+ * than 2500 frames a second for as long as the queue has stood: past anything a
+ * person, a session or a peer produces, and into the storm this layer exists
+ * for. What is over the limit is refused rather than dropped quietly, so the op
+ * that raised it is the one that hears about it. */
+export const QUEUE_LIMIT = 256;
+
+/** The two things the queue asks of time, so a test can hold both still.
+ *
+ * `schedule` answers with the way to cancel what it armed, because a terminal
+ * that goes away while a flush is pending has to leave nothing behind. */
+export interface EgressClock {
+  now(): number;
+  schedule(afterMs: number, run: () => void): () => void;
+}
+
+const REAL_CLOCK: EgressClock = {
+  now: () => Date.now(),
+  schedule: (afterMs, run) => {
+    const timer = setTimeout(run, afterMs);
+    return () => {
+      clearTimeout(timer);
+    };
+  },
+};
+
+/** What a caller may move: the period, the limit, and the clock both are read
+ * against. */
+export interface EgressOptions {
+  readonly periodMs?: number;
+  readonly limit?: number;
+  readonly clock?: EgressClock;
+}
+
+interface Pending {
+  /** The key this frame folds on, absent for one that does not fold. */
+  readonly fold?: string;
+  frame: object;
+}
+
+/** One terminal's outgoing frames, gathered and let go on a period.
+ *
+ * A terminal is a person's connection, a mesh peer or a CLI subscriber, and
+ * this is the same layer for all three: what differs between them is the socket
+ * underneath, not how fast a subscriber can be written to.
+ *
+ * Three things happen here, and the topic's own granularity decides which. A
+ * frame that replaces the value it carries folds onto the one already waiting
+ * under the same key, so a value stated a thousand times between two flushes
+ * leaves one frame and it is the latest — the reader is never handed a value
+ * that has already been superseded, and never misses the last one. A frame that
+ * is an occurrence or a delta cannot fold, so it queues in the order it was
+ * raised and the queue is bounded: past the bound the frame is refused, which is
+ * how the pressure reaches whoever is producing it instead of accumulating
+ * here. Both leave together on the flush, in the order they were queued.
+ *
+ * The first frame after a quiet spell goes out at once: the period bounds how
+ * often a flush happens, not how long a lone change waits. */
+export class Egress {
+  #queue: Pending[] = [];
+  /** The waiting frame per fold key, so a restatement finds its own entry
+   * rather than being appended behind it. */
+  readonly #folded = new Map<string, Pending>();
+  /** How many waiting frames do not fold, which is what the limit counts. */
+  #kept = 0;
+  #lastFlush = Number.NEGATIVE_INFINITY;
+  #cancel: (() => void) | undefined;
+
+  readonly #periodMs: number;
+  readonly #limit: number;
+  readonly #clock: EgressClock;
+
+  constructor(
+    private readonly conn: Requester,
+    options: EgressOptions = {},
+  ) {
+    this.#periodMs = options.periodMs ?? FLUSH_PERIOD_MS;
+    this.#limit = options.limit ?? QUEUE_LIMIT;
+    this.#clock = options.clock ?? REAL_CLOCK;
+  }
+
+  /** Take one frame for this terminal. `fold` is the key it replaces itself
+   * under, absent for a frame that has to be sent as often as it is raised.
+   *
+   * `false` is the queue refusing the frame: it is full of frames that cannot
+   * be folded, and the caller is the one that can answer for it. */
+  push(frame: object, fold?: string): boolean {
+    if (fold === undefined) {
+      if (this.#kept >= this.#limit) return false;
+      this.#kept += 1;
+      this.#queue.push({ frame });
+    } else {
+      const held = this.#folded.get(fold);
+      if (held !== undefined) {
+        // In place: the value moves, its position among the occurrences around
+        // it does not.
+        held.frame = frame;
+        this.#arm();
+        return true;
+      }
+      const entry: Pending = { fold, frame };
+      this.#queue.push(entry);
+      this.#folded.set(fold, entry);
+    }
+    this.#arm();
+    return true;
+  }
+
+  /** Send everything waiting, in the order it was queued. */
+  flush(): void {
+    this.#cancel?.();
+    this.#cancel = undefined;
+    this.#lastFlush = this.#clock.now();
+    const queue = this.#queue;
+    this.#queue = [];
+    this.#folded.clear();
+    this.#kept = 0;
+    for (const entry of queue) this.conn.send(entry.frame);
+  }
+
+  /** The terminal is done with: what was queued goes out, and nothing armed
+   * outlives it. */
+  release(): void {
+    this.flush();
+  }
+
+  #arm(): void {
+    if (this.#cancel !== undefined) return;
+    const wait = this.#periodMs - (this.#clock.now() - this.#lastFlush);
+    if (wait <= 0) {
+      this.flush();
+      return;
+    }
+    this.#cancel = this.#clock.schedule(wait, () => {
+      this.#cancel = undefined;
+      this.flush();
+    });
+  }
+}

package/src/topics/index.ts

@@ -1,2 +1,3 @@
+export * from "./egress.ts";
 export * from "./handlers.ts";
 export * from "./topics.ts";

package/src/transport/listener.ts

@@ -4,6 +4,9 @@
  * everything else, because a client reads "the unix socket refuses" as the
  * instance having finished leaving, and a successor may take the resources it
  * sees freed before that. */
+/** A Bun listener gets this long to settle after releasing its address. */
+export const STOP_DEADLINE_MS = 250;
+
 export interface Listener {
   readonly kind: "uds" | "ws";
   /** The socket path, or the bound `host:port` — resolved, so an ephemeral
@@ -29,11 +32,13 @@ export class Transport {
    * come before this one (§8.5 1-4: refuse new work, stop upstream watches,
    * tell the connections, settle what is persisted). */
   async close(): Promise<void> {
-    const ordered = [
-      ...this.#listeners.filter((l) => l.kind !== "uds"),
-      ...this.#listeners.filter((l) => l.kind === "uds"),
-    ];
+    const held = [...this.#listeners];
     this.#listeners.length = 0;
-    for (const listener of ordered) await listener.close();
+    // The order that matters is the unix socket coming last; among the rest
+    // there is none, and closing them one after another would add up their
+    // deadlines for no reason — two served listeners is a second of waiting
+    // that nothing is waiting for.
+    await Promise.all(held.filter((l) => l.kind !== "uds").map((l) => l.close()));
+    for (const listener of held.filter((l) => l.kind === "uds")) await listener.close();
   }
 }

package/src/transport/uds.ts

@@ -81,8 +81,11 @@ export function listenUds(options: UdsOptions): Listener {
   return {
     kind: "uds",
     address: options.path,
-    async close() {
+    close() {
+      // Nothing to wait on: a unix listener gives its address up inside the
+      // call, unlike the served WebSocket next door (Bun 1.3.13).
       server.stop(true);
+      return Promise.resolve();
     },
   };
 }

package/src/transport/ws.ts

@@ -3,7 +3,7 @@ import { BaseConn, type Conn, type ConnRegistry } from "./conn.ts";
 import { createDriver, type FrameHandler } from "./driver.ts";
 import { LineReader, WriteQueue } from "./framing.ts";
 import { type AuthorizedUpgrade, type EntryPolicy, OPEN } from "./entry.ts";
-import type { Listener } from "./listener.ts";
+import { type Listener, STOP_DEADLINE_MS } from "./listener.ts";
 
 /** What the upgrade hands the socket: whether it was let in as a peer. */
 interface UpgradeData {
@@ -186,8 +186,4 @@ export function entryPath(pathname: string, path: string): boolean {
   return pathname === path || pathname.endsWith(`/${path.replace(/^\//, "")}`);
 }
 
-/** How long the stop above waits before trusting the address over the promise.
- * Two orders of magnitude above the millisecond the release was measured at. */
-const STOP_DEADLINE_MS = 250;
-
 const NEWLINE = new Uint8Array([0x0a]);