opencode-courier 0.2.3 → 0.4.0

package/dist/platform/events.d.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from "@opencode/plugin";
+import type { Hub } from "./hub.js";
+/** One of OpenCode's events, as a subscription yields it. */
+export interface HostEvent {
+    readonly type: string;
+    readonly data?: unknown;
+}
+/** What following OpenCode's events needs of a member's ports: the stream, and a log. */
+export interface EventPorts {
+    readonly event: Pick<Plugin.Context["event"], "subscribe">;
+    readonly log: (message: string) => void;
+}
+/** What a module does with OpenCode's events, by phase; each phase runs the modules in list order. */
+export interface EventModule<P extends EventPorts> {
+    /** For each event; the first to throw ends the phase. */
+    readonly handle?: (ports: P, event: HostEvent) => Promise<unknown> | undefined;
+    /** For each event, once the `handle` phase has ended, however it did; the first to throw ends this one too. */
+    readonly after?: (ports: P, event: HostEvent) => Promise<void> | undefined;
+    /** As a subscription starts; returns what to run at its first event, if anything. */
+    readonly followed?: () => (() => void) | undefined;
+    /** Alongside each (re)subscription; the watcher's end waits for it. */
+    readonly subscribed?: (ports: P) => Promise<void>;
+    /** Once a subscription has ended or broken. */
+    readonly left?: () => void;
+}
+/** How long to wait before subscribing again after the event stream ended or broke. */
+export declare const RESUBSCRIBE_MS = 5000;
+/** Follows OpenCode's events through `ports`, subscribing again after `retryMs` when a subscription ends, until `signal` aborts. */
+export declare function follow<P extends EventPorts>(ports: P, modules: readonly EventModule<P>[], signal: AbortSignal, retryMs?: number): Promise<void>;
+/**
+ * Makes the hub start its subscriptions to OpenCode's events with this copy's modules, the copy loaded
+ * last; `join` starts them. The second is a standby, connected before the first's member leaves.
+ */
+export declare function watchFromHub<P extends EventPorts>(hub: Pick<Hub, "subscribe">, modules: readonly EventModule<P>[], retryMs?: number): void;

package/dist/platform/events.js

@@ -0,0 +1,121 @@
+/** How long to wait before subscribing again after the event stream ended or broke. */
+export const RESUBSCRIBE_MS = 5_000;
+const pause = (ms, signal) => new Promise((resolve) => {
+    const timer = setTimeout(done, ms);
+    function done() {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        resolve();
+    }
+    signal.addEventListener("abort", done);
+});
+const ENDED = { done: true, value: undefined };
+/**
+ * `events` until it ends or `signal` aborts, the stream left open; each wait hears the abort only while
+ * it waits, so a watcher that follows events for the life of the process holds nothing per event.
+ */
+const until = (events, signal) => ({
+    [Symbol.asyncIterator]: () => ({
+        next: () => new Promise((resolve, reject) => {
+            if (signal.aborted)
+                return resolve(ENDED);
+            const stop = () => resolve(ENDED);
+            signal.addEventListener("abort", stop, { once: true });
+            // Once the signal has aborted, whatever the stream ends this wait with is not wanted.
+            events.next().then((next) => {
+                signal.removeEventListener("abort", stop);
+                resolve(next);
+            }, (error) => {
+                signal.removeEventListener("abort", stop);
+                reject(error);
+            });
+        }),
+    }),
+});
+/** One event through the `handle` phase, then, however that ended, the `after` phase. */
+async function handle(ports, modules, event) {
+    try {
+        for (const module of modules) {
+            const handling = module.handle?.(ports, event);
+            if (handling)
+                await handling;
+        }
+    }
+    finally {
+        for (const module of modules) {
+            const after = module.after?.(ports, event);
+            if (after)
+                await after;
+        }
+    }
+}
+/** Handles one event, logging a failure rather than ending the watch. */
+function handleLogged(ports, modules, event) {
+    return handle(ports, modules, event).catch((error) => {
+        const data = event.data;
+        const sessionID = data?.sessionID ?? data?.form?.sessionID;
+        ports.log(`courier watch: could not handle ${event.type} of ${sessionID}: ${String(error)}`);
+    });
+}
+/** Runs each module's `subscribed` alongside the new subscription, kept in `alongside` until done. */
+function subscribed(ports, modules, alongside) {
+    for (const module of modules) {
+        if (!module.subscribed)
+            continue;
+        const running = module
+            .subscribed(ports)
+            .catch((error) => ports.log(`courier watch: ${String(error)}`))
+            .finally(() => alongside.delete(running));
+        alongside.add(running);
+    }
+}
+/** One subscription, its events through `modules`' phases, until its stream ends or breaks or `signal` aborts. */
+async function subscription(ports, modules, signal, alongside) {
+    let following = false;
+    let events;
+    try {
+        events = ports.event.subscribe({ signal })[Symbol.asyncIterator]();
+        let first = modules.flatMap((module) => module.followed?.() ?? []);
+        following = true;
+        subscribed(ports, modules, alongside);
+        for await (const event of until(events, signal)) {
+            for (const run of first)
+                run();
+            first = [];
+            await handleLogged(ports, modules, event);
+        }
+    }
+    catch (error) {
+        if (!signal.aborted)
+            ports.log(`courier watch: event stream broke: ${String(error)}`);
+    }
+    finally {
+        if (following)
+            for (const module of modules)
+                module.left?.();
+        // Closed without waiting: closing the adapter's stream waits on OpenCode, which may not answer
+        // while a location closes, and the leave waiting for this watcher must not wait for that too.
+        void events?.return?.().catch(() => { });
+    }
+}
+/** Follows OpenCode's events through `ports`, subscribing again after `retryMs` when a subscription ends, until `signal` aborts. */
+export async function follow(ports, modules, signal, retryMs = RESUBSCRIBE_MS) {
+    const alongside = new Set();
+    while (!signal.aborted) {
+        await subscription(ports, modules, signal, alongside);
+        if (!signal.aborted)
+            await pause(retryMs, signal);
+    }
+    await Promise.allSettled(alongside);
+}
+/**
+ * Makes the hub start its subscriptions to OpenCode's events with this copy's modules, the copy loaded
+ * last; `join` starts them. The second is a standby, connected before the first's member leaves.
+ */
+export function watchFromHub(hub, modules, retryMs = RESUBSCRIBE_MS) {
+    hub.subscribe = (member) => {
+        const stop = new AbortController();
+        // A member of any copy runs them: every hub-v2 member's `watch` ports are the same shape.
+        return { member, stop, done: follow(member.watch, modules, stop.signal, retryMs) };
+    };
+}

package/dist/platform/hub.d.ts

@@ -0,0 +1,195 @@
+import { type Registry, type Storage } from "./storage.js";
+/**
+ * The plugin's process-wide state on `globalThis`, shared by every loaded copy; only this module puts
+ * it there. `HUB_VERSION`, the fixed claim keys and version skew: docs/maintainers/architecture.md, § Several copies in one process.
+ */
+export declare const HUB_VERSION = 2;
+/** The key of the hub; a copy that finds another version there keeps its own under `${HUB_KEY}@<version>`. */
+export declare const HUB_KEY = "opencode-courier.hub";
+/** The ports a member's scheduler keeps the owner key through: what every member's `later` ports have. */
+export interface TickPorts {
+    readonly storage: Pick<Storage, "get" | "set" | "remove">;
+    readonly now: () => number;
+}
+/**
+ * The events handled, and the permission requests a session was told about or that were answered
+ * first: claim sets shared by every subscription and copy, so each event is handled once.
+ */
+export interface Watched {
+    readonly seen: Set<string>;
+    readonly waiting: Set<string>;
+    readonly answered: Set<string>;
+}
+/** The forms sessions were told about, kept apart from the permission requests. */
+export interface FormsTold {
+    /** Forms still shown whose notice went out, or is going out: the notice's delivery. */
+    readonly told: Map<string, Promise<unknown>>;
+    /** Forms settled before anyone was told, so a notice whose roster lookup was overtaken is not sent. */
+    readonly settled: Set<string>;
+}
+/**
+ * A loaded plugin instance: its location's directory and permission domain, and the ports a job
+ * run once for the whole process would run it through.
+ */
+export interface Member {
+    readonly directory: string;
+    /**
+     * The location OpenCode set the instance up with, the very object the instance's Effect half is
+     * handed too, which finds its member by it (`portsAt`). A member of a copy before it has none.
+     */
+    readonly location?: object;
+    /** The location's permission domain, kept in `locations`. */
+    readonly permission: unknown;
+    /** The ports the scheduler's tick runs through: the owner key's, and the tick jobs'. */
+    readonly later: TickPorts;
+    /** The ports the hub's subscriptions to OpenCode's events run through. */
+    readonly watch: unknown;
+    /** The question relay's ports. */
+    readonly questions: unknown;
+    readonly log: (message: string) => void;
+}
+/**
+ * A tick under way: the member it runs through, when it started, by the wall clock every member's
+ * `now` reads (the next ticks compare it with another member's), and its end.
+ */
+export interface Tick {
+    readonly member: Member;
+    readonly since: number;
+    /** Settles once the tick has ended, the owner key released if its loop stopped meanwhile; never rejects. */
+    readonly done: Promise<void>;
+}
+/**
+ * The scheduler's loop, one per hub: it runs while the hub has members, and each tick runs the jobs
+ * registered with `open` through the ports of the member that joined first and is still loaded.
+ */
+export interface Scheduler {
+    /** The loop's interval, while it runs. */
+    timer?: unknown;
+    /**
+     * The tick under way, whichever copy started it: for a minute the key is renewed for it and due
+     * ticks skip; past it, one whose member left holds nothing up. Older copies have only `ticking`.
+     */
+    running?: Tick;
+    /**
+     * The member the tick under way runs through, if any, set and cleared with `running`, for a copy
+     * that reads only this: a tick that falls due meanwhile is skipped, unless that member has left.
+     */
+    ticking?: Member;
+    /** One tick, by the copy of the plugin that joined last, so a copy loaded after an update runs its own code. */
+    tick?: () => Promise<void>;
+    /** Whether a nudge came since the tick under way started, whichever copy's, so it ticks once more when done. */
+    nudged?: boolean;
+}
+/** How the hub starts and stops the scheduler's loop, and waits before re-reading the owner key; tests pass their own. */
+export interface Timers {
+    readonly every: (run: () => void, ms: number) => unknown;
+    readonly stop: (timer: unknown) => void;
+    readonly wait: (ms: number) => Promise<void>;
+}
+/** How often the hub's scheduler ticks: what a job delivers, a `courier_later` message, can be this late. */
+export declare const TICK_MS = 15000;
+/**
+ * The storage key, shared by every server on one data directory, naming the server whose scheduler
+ * delivers `courier_later` messages: `{ server, at }`, its id and when it last wrote (epoch ms).
+ */
+export declare const OWNER_KEY = "scheduler/owner";
+/** How long the owner key holds without being renewed; the owner renews it every tick, four times as often. */
+export declare const OWNER_EXPIRY_MS: number;
+/**
+ * How old the owner's own key may be for it to renew the key and deliver at once. An older one,
+ * which it may no longer hold by the time it writes, is taken again like a free one, with the wait.
+ */
+export declare const OWNER_RENEW_MS: number;
+/** The wait between writing the owner key and reading it back, at least `OWNER_WAIT_MS` and up to twice that. */
+export declare const OWNER_WAIT_MS = 500;
+/**
+ * This server's id in the owner key: the same for every copy of the plugin in the process, and
+ * different in every other process, a restart of this one included.
+ */
+export declare const SERVER: string;
+/**
+ * How long an unloading instance waits for the work it leaves behind: what it started itself, a tick
+ * or a notice under way through it, and on the last leave the owner key's release.
+ */
+export declare const LEAVE_MS = 2000;
+/** How many subscriptions to OpenCode's events a hub keeps, each through another member: one, and a standby. */
+export declare const WATCHERS = 2;
+/** One of the hub's subscriptions to OpenCode's events: the member whose ports it runs through, and how it ends. */
+export interface Watcher {
+    readonly member: Member;
+    readonly stop: AbortController;
+    /** Settles once the subscription has ended, after `stop`: after the event it is handling, not the stream's close. */
+    readonly done: Promise<void>;
+}
+export interface Hub {
+    readonly version: typeof HUB_VERSION;
+    /** The instances loaded now, in the order they joined. */
+    readonly members: Set<Member>;
+    readonly scheduler: Scheduler;
+    /**
+     * The hub's subscriptions to OpenCode's events, each through another member: two while two members
+     * are loaded, so one is always connected when the other's member leaves.
+     */
+    readonly watchers: Watcher[];
+    /**
+     * Starts a subscription through a member, by the copy of the plugin that set it last; until one
+     * has, the hub follows no events.
+     */
+    subscribe?: (member: Member) => Watcher;
+    /** The ids of the `courier_later` messages being delivered. */
+    readonly claimed: Set<string>;
+    /** The events handled, and the permission requests a session was told about or that were answered first. */
+    readonly watched: Watched;
+    /** The forms sessions were told about, and those settled first. */
+    readonly forms: FormsTold;
+    /**
+     * The permission domain of every loaded instance, by instance. OpenCode keeps a request where its
+     * session runs, so a request of an isolated child is answered through the instance loaded in its worktree.
+     */
+    readonly locations: Map<object, unknown>;
+    /** The webhook receiver's state: the object every copy shares under the key `receiver`. */
+    readonly receivers: object;
+    /** The question relay's state: the object every copy shares under the key `questions`. */
+    readonly questions: object;
+    /** Whether the hub of another version found under `HUB_KEY` has been logged. */
+    skewLogged: boolean;
+}
+/**
+ * A job each tick runs, in its turn, through the first loaded member, which may be another copy's:
+ * it uses only the ports every hub-v2 member has. `claimed` is the hub's claim set; a throw ends the tick.
+ */
+export type TickJob = (owner: Member, claimed: Set<string>) => Promise<void>;
+/** A hub, as `open` finds or makes it, and how instances join it. */
+export interface Opened {
+    readonly hub: Hub;
+    /**
+     * Adds a loaded instance to the hub and `locations`; returns its leave. The first join starts the
+     * scheduler and watchers, the last leave stops them; a leave waits `LEAVE_MS` for the member's work.
+     */
+    readonly join: (member: Member) => () => Promise<void>;
+    /** Hands the hub work a member started, which its leave waits for; the member's own background work. */
+    readonly track: (member: Member, work: Promise<unknown>) => void;
+    /**
+     * Runs a tick now, or once the tick under way has ended, so what has just fallen due (a released
+     * group) is delivered at once rather than at the next tick; nothing while no instance is loaded.
+     */
+    readonly nudge: () => void;
+}
+/**
+ * The value under `opencode-courier.<name>` every copy in the process shares, made by `create` the first
+ * time; another version, or a copy before the hub, may have made it, so its shape is kept for good.
+ */
+export declare function sharedState<T>(name: string, create: () => T, registry?: Registry): T;
+/**
+ * This copy's hub in `registry`, and how its instances join it. Its ticks run `jobs` in order, kept in
+ * this copy's tick, which the hub runs once this copy has joined last, never in the hub itself.
+ */
+export declare function open(registry: Registry, jobs: readonly TickJob[], timers?: Timers, server?: string): Opened;
+/** This copy's hub, in the process. */
+export declare const hub: Hub;
+/** Opens this copy's hub in the process, with its tick jobs; see `open`. */
+export declare const openInProcess: (jobs: readonly TickJob[]) => Opened;
+/** The member of this copy's hub set up with `location` that joined last, while it is loaded. */
+export declare function memberAt(location: object): Member | undefined;
+/** The permission domains of the loaded instances. */
+export declare const permissions: () => MapIterator<unknown>;

package/dist/{hub.js → platform/hub.js}

@@ -1,33 +1,12 @@
 import { randomInt } from "node:crypto";
 import { hostname } from "node:os";
 import { num, obj, str } from "./json.js";
-import { deliverDue, TICK_MS } from "./later.js";
 import { processWide } from "./storage.js";
 /**
- * The plugin's process-wide state, in one place. OpenCode sets the plugin up once per location
- * (project or worktree), all in one process, and after an update loads the new copy of the package
- * next to the old one until the old one unloads; so the state every instance shares lives on
- * `globalThis`, outside the module graph, and this is the only module that puts it there.
- *
- * The hub is versioned by `HUB_VERSION`, not by the package's version: copies whose hub has the
- * same shape share one hub, however far apart their releases, and only a change to the hub's shape
- * (the ports a `Member` carries included) or to the meaning of one of its fields bumps it. An
- * optional field that a copy without it gets along without, such as `Member.location` or
- * `Scheduler.running`, is added without a bump while no release has the hub (the latest is 0.2.2).
- *
- * Version skew: a copy that finds a hub of another version under `opencode-courier.hub` logs that
- * once and runs its own hub under `opencode-courier.hub@<version>`. Whatever its version, a hub
- * takes the claim sets and the other shared objects of the copies before the hub from their own
- * keys (`opencode-courier.claimed`, `.watched`, `.forms`, `.questions`, `.receiver`, `.locations`),
- * making each when it is missing, so every copy in the process, with a hub or without, claims an
- * event or a delivery in the same set, and an old and a new copy never both act on it. Those keys'
- * shapes and meanings are therefore fixed: a hub version that needs other ones makes new keys, and
- * keeps claiming in the old ones too while a copy that uses them may still be loaded. `members` is
- * the one thing each version keeps to itself, so a job a hub runs once for its members runs once
- * per hub version, and still claims what it acts on in the shared sets, which keep it from acting
- * twice.
+ * The plugin's process-wide state on `globalThis`, shared by every loaded copy; only this module puts
+ * it there. `HUB_VERSION`, the fixed claim keys and version skew: docs/maintainers/architecture.md, § Several copies in one process.
  */
-export const HUB_VERSION = 1;
+export const HUB_VERSION = 2;
 /** The key of the hub; a copy that finds another version there keeps its own under `${HUB_KEY}@<version>`. */
 export const HUB_KEY = "opencode-courier.hub";
 const realTimers = {
@@ -35,11 +14,11 @@ const realTimers = {
     stop: (timer) => clearInterval(timer),
     wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
 };
+/** How often the hub's scheduler ticks: what a job delivers, a `courier_later` message, can be this late. */
+export const TICK_MS = 15_000;
 /**
- * The key in the plugin's storage, shared by every OpenCode server on one data directory, naming
- * the server whose scheduler delivers the `courier_later` messages: `{ server, at }`, its id and
- * when it last wrote the key, in epoch milliseconds. Outside `later/`, which the schedulers scan
- * for messages, those of copies before the key included.
+ * The storage key, shared by every server on one data directory, naming the server whose scheduler
+ * delivers `courier_later` messages: `{ server, at }`, its id and when it last wrote (epoch ms).
  */
 export const OWNER_KEY = "scheduler/owner";
 /** How long the owner key holds without being renewed; the owner renews it every tick, four times as often. */
@@ -63,9 +42,8 @@ async function readOwner(ports) {
     return server !== undefined && at !== undefined ? { server, at } : undefined;
 }
 /**
- * How long an unloading instance waits, before it lets go, for the work it leaves behind: what it
- * started itself, a tick or an event's notice still under way through it, and on the last leave the
- * owner key's release.
+ * How long an unloading instance waits for the work it leaves behind: what it started itself, a tick
+ * or a notice under way through it, and on the last leave the owner key's release.
  */
 export const LEAVE_MS = 2_000;
 /** Whether a key written at `at` still holds at `now`; one from the future, after the clock went back, holds as long. */
@@ -73,27 +51,18 @@ const holds = (at, now, ms) => Math.abs(now - at) < ms;
 /** How many subscriptions to OpenCode's events a hub keeps, each through another member: one, and a standby. */
 export const WATCHERS = 2;
 /**
- * Finds or makes this copy's hub in `registry`: the one under `HUB_KEY`, or its own under a
- * versioned key when a hub of another version holds that. Either way, its claim sets and shared
- * objects are the ones under the keys of the copies before the hub, made when missing.
+ * The value under `opencode-courier.<name>` every copy in the process shares, made by `create` the first
+ * time; another version, or a copy before the hub, may have made it, so its shape is kept for good.
  */
-export function open(registry, timers = realTimers, server = SERVER) {
-    const shared = (name, create) => processWide(`opencode-courier.${name}`, create, registry);
-    const questionState = () => {
-        // Field by field, since a copy before the hub may have made it without the fields added later.
-        const state = shared("questions", () => ({}));
-        state.questions ??= new Map();
-        state.noticed ??= new Set();
-        state.shown ??= new Map();
-        state.passing ??= new Map();
-        state.answered ??= new Set();
-        state.loaded ??= new Set();
-        state.following ??= 0;
-        state.followed ??= false;
-        state.shutdowns ??= new Map();
-        state.closingWaiters ??= new Set();
-        return state;
-    };
+export function sharedState(name, create, registry = globalThis) {
+    return processWide(`opencode-courier.${name}`, create, registry);
+}
+/**
+ * Finds or makes this copy's hub in `registry`: the one under `HUB_KEY`, or its own under a versioned
+ * key when another version holds that; its claim sets are the pre-hub keys', made when missing.
+ */
+function find(registry) {
+    const shared = (name, create) => sharedState(name, create, registry);
     const create = () => ({
         version: HUB_VERSION,
         members: new Set(),
@@ -104,17 +73,24 @@ export function open(registry, timers = realTimers, server = SERVER) {
         forms: shared("forms", () => ({ told: new Map(), settled: new Set() })),
         locations: shared("locations", () => new Map()),
         receivers: shared("receiver", () => ({})),
-        questions: questionState(),
+        // Filled in by `person/question/`, field by field, since a copy before the hub may have made it without them.
+        questions: shared("questions", () => ({})),
         skewLogged: false,
     });
     const found = registry[Symbol.for(HUB_KEY)];
     // The version of the hub of another copy found under `HUB_KEY`, if one is there.
     const skew = found != null && found.version !== HUB_VERSION ? { version: found.version } : undefined;
-    const hub = processWide(skew ? `${HUB_KEY}@${HUB_VERSION}` : HUB_KEY, create, registry);
+    return { hub: processWide(skew ? `${HUB_KEY}@${HUB_VERSION}` : HUB_KEY, create, registry), skew };
+}
+/**
+ * This copy's hub in `registry`, and how its instances join it. Its ticks run `jobs` in order, kept in
+ * this copy's tick, which the hub runs once this copy has joined last, never in the hub itself.
+ */
+export function open(registry, jobs, timers = realTimers, server = SERVER) {
+    const { hub, skew } = find(registry);
     /**
-     * Whether this server holds the owner key, taking or renewing it through `ports`. Its own fresh
-     * key is renewed. A free one, an expired one, or its own after a stall, is written and read back
-     * after a random wait: of two servers taking it at once, the one that wrote last holds it.
+     * Whether this server holds the owner key, taking or renewing it through `ports`. A free, expired
+     * or stalled key is written and read back after a random wait: the last of two writers holds it.
      */
     const own = async (ports) => {
         const held = await readOwner(ports);
@@ -142,10 +118,8 @@ export function open(registry, timers = realTimers, server = SERVER) {
         return other !== hub && (name === HUB_KEY || name.startsWith(`${HUB_KEY}@`)) && Number(other?.members?.size) > 0;
     });
     /**
-     * Removes the owner key if this server holds it, so another server takes over at its next tick:
-     * once the loop has stopped and no tick is under way, whichever copy started it (a tick whose loop
-     * stopped releases it as it ends), and while no hub of another version in the process still runs a
-     * loop under the same id.
+     * Removes the owner key if this server holds it, so another takes over at its next tick: once the
+     * loop has stopped, no tick is under way and no other hub version here runs a loop under this id.
      */
     const release = async (ports) => {
         const scheduler = hub.scheduler;
@@ -154,30 +128,33 @@ export function open(registry, timers = realTimers, server = SERVER) {
             await ports.storage.remove(OWNER_KEY);
     };
     /**
-     * Whether the tick under way, kept on the hub by whichever copy started it, still holds up the
-     * next: within a minute of its start it does, and the key is renewed for it, through the first
-     * member still loaded, since a delivery may run longer than the key holds; past the minute it is
-     * taken to hang, and holds up the next only while its member is still loaded. A tick of a copy that
-     * keeps only `ticking` holds it up while its member is loaded, without renewing the key.
+     * Whether the tick under way still holds the next up: within a minute of its start it does; past
+     * that it is taken to hang, holding up only while its member is loaded. `recent` says which.
      */
-    const underWay = () => {
+    const busy = () => {
         const { running, ticking } = hub.scheduler;
         if (!running)
-            return ticking !== undefined && hub.members.has(ticking);
+            return { busy: ticking !== undefined && hub.members.has(ticking), recent: false };
+        const first = hub.members.values().next().value;
+        if (first && holds(running.since, first.later.now(), OWNER_EXPIRY_MS))
+            return { busy: true, recent: true };
+        return { busy: hub.members.has(running.member), recent: false };
+    };
+    /** `busy`, renewing the key for a recent tick under way, as each tick falling due meanwhile does. */
+    const underWay = () => {
+        const state = busy();
         const first = hub.members.values().next().value;
-        if (first && holds(running.since, first.later.now(), OWNER_EXPIRY_MS)) {
+        if (state.recent && first)
             void renew(first.later).catch((error) => first.log(`courier_later scheduler: ${String(error)}`));
-            return true;
-        }
-        return hub.members.has(running.member);
+        return state.busy;
     };
-    // One tick, through the first member still loaded, by the server holding the owner key. The claim
-    // on each delivery stays, as the second line of defence against a copy before the hub, which runs
-    // its own interval until it unloads, and has no owner key.
+    // One tick, through the first loaded member, by the server holding the owner key. The claim on each
+    // delivery stays, as a second line of defence against a pre-hub copy running its own interval.
     const tick = async () => {
         const scheduler = hub.scheduler;
         if (underWay())
             return;
+        scheduler.nudged = false;
         const owner = hub.members.values().next().value;
         if (!owner)
             return;
@@ -202,8 +179,10 @@ export function open(registry, timers = realTimers, server = SERVER) {
             catch { }
         };
         try {
-            if ((await own(owner.later)) && scheduler.timer !== undefined && hub.members.has(owner))
-                await deliverDue(owner.later, hub.claimed);
+            if ((await own(owner.later)) && scheduler.timer !== undefined && hub.members.has(owner)) {
+                for (const job of jobs)
+                    await job(owner, hub.claimed);
+            }
         }
         catch (error) {
             tell(`courier_later scheduler: ${String(error)}`);
@@ -219,6 +198,18 @@ export function open(registry, timers = realTimers, server = SERVER) {
         if (scheduler.timer === undefined)
             await release(owner.later).catch((error) => tell(`courier_later scheduler: owner key not released: ${String(error)}`));
         end();
+        if (scheduler.nudged && scheduler.timer !== undefined)
+            void scheduler.tick?.();
+    };
+    // Through the hub's tick, the copy loaded last's, like the loop's; this copy's only before one joined. A
+    // tick under way runs once more when it ends, so nothing is started here meanwhile.
+    const nudge = () => {
+        const scheduler = hub.scheduler;
+        if (scheduler.timer === undefined)
+            return;
+        scheduler.nudged = true;
+        if (!busy().busy)
+            void (scheduler.tick ?? tick)();
     };
     // Subscriptions through the earliest members without one, the longest loaded, until there are
     // `WATCHERS`; never through `leaving`.
@@ -262,9 +253,8 @@ export function open(registry, timers = realTimers, server = SERVER) {
             const behind = [...(work.get(member) ?? [])];
             if (scheduler.running?.member === member)
                 behind.push(scheduler.running.done);
-            // The other subscription, already connected, follows the events meanwhile; this one is
-            // replaced before it ends, so the question relay's count of watchers never drops to none.
-            // It ends once the event it is handling, whose notice may be going out, has been handled.
+            // The other subscription, already connected, follows the events meanwhile; this one is replaced
+            // before it ends, after its current event, so the relay's watcher count never drops to none.
             const index = hub.watchers.findIndex((watcher) => watcher.member === member);
             if (index >= 0) {
                 const [leaving] = hub.watchers.splice(index, 1);
@@ -286,15 +276,17 @@ export function open(registry, timers = realTimers, server = SERVER) {
             return Promise.race([Promise.allSettled(behind).then(() => { }), timers.wait(LEAVE_MS)]);
         };
     };
-    return { hub, join, track };
+    return {
+        hub,
+        join,
+        track,
+        nudge,
+    };
 }
-const opened = open(globalThis);
 /** This copy's hub, in the process. */
-export const hub = opened.hub;
-/** Joins this copy's hub; see `Opened.join`. */
-export const join = opened.join;
-/** Hands this copy's hub work a member started; see `Opened.track`. */
-export const track = opened.track;
+export const hub = find(globalThis).hub;
+/** Opens this copy's hub in the process, with its tick jobs; see `open`. */
+export const openInProcess = (jobs) => open(globalThis, jobs);
 /** The member of this copy's hub set up with `location` that joined last, while it is loaded. */
 export function memberAt(location) {
     let found;
@@ -303,38 +295,5 @@ export function memberAt(location) {
             found = member;
     return found;
 }
-/**
- * The question ports of the member that has just joined at `location`, the newest there, for as long
- * as it stays loaded: resolved once, so an instance joining later at the same location, while this
- * one is still loaded, does not take its place.
- */
-export function portsAt(location) {
-    const own = memberAt(location);
-    return () => (own && hub.members.has(own) ? own.questions : undefined);
-}
 /** The permission domains of the loaded instances. */
 export const permissions = () => hub.locations.values();
-/**
- * For tests: forgets every remembered id and the question relay's state, the relay's loaded
- * instances and its count of watchers included. The hub's members, the locations and the webhook
- * receiver are left alone; leaving and unloading take them out.
- */
-export function resetHub() {
-    hub.claimed.clear();
-    hub.watched.seen.clear();
-    hub.watched.waiting.clear();
-    hub.watched.answered.clear();
-    hub.forms.told.clear();
-    hub.forms.settled.clear();
-    const questions = hub.questions;
-    questions.questions.clear();
-    questions.noticed.clear();
-    questions.shown.clear();
-    questions.passing.clear();
-    questions.answered.clear();
-    questions.loaded.clear();
-    questions.following = 0;
-    questions.followed = false;
-    questions.shutdowns.clear();
-    questions.closingWaiters.clear();
-}