@platless/axom-cli 0.1.0 → 0.5.9

package/dist/workstation/acp/uvxInstall.js

@@ -1,19 +1,16 @@
 /**
- * The `uv tool` counterpart to `installProbe.ts`: uvx-distributed adapters (`fast-agent`,
- * `minion-code` — see the ACP registry's `distribution.uvx`) are, from this task on, installed by
- * us with `uv tool install` rather than launched with `uvx <pkg>`. That switch is the whole point
- * of this module.
+ * `uv tool` plumbing for uvx-distributed adapters (`fast-agent-acp`, `minion-code` — the ACP
+ * registry's `distribution.uvx`). Since Task 15b these are installed as daemon-owned, per-version
+ * builds (`builds/install/uv.ts`): every `uv` call here runs with `UV_TOOL_DIR`/`UV_TOOL_BIN_DIR`
+ * pointed into one build's own directory, never at the user's `uv tool dir` or `~/.local/bin`, and only
+ * at install time — a launch reads the entry recorded in `builds.json` and never starts `uv`.
  *
- * ## Why the launch path had to change, not just the probe
+ * ## Why not `uvx <pkg>`
  *
  * `uvx <pkg>` resolves through uv's own ephemeral-environment cache — directories named by a hash
  * of the resolved environment, a layout this codebase has never verified and has no reason to
- * trust. "Is it installed, and which version" is unanswerable against that cache the same way it
- * would be unanswerable against npm's `_npx/<hash>` before `installProbe.ts` existed. `uv tool
- * install` instead puts the tool under `uv tool dir` — one stable path per machine that `uv tool
- * list` describes completely — which is the same guarantee `readNpxCache`/`findOnPath` give for the
- * npx and binary paths. Everything here exists to read that directory the way `installProbe.ts`
- * reads npm's.
+ * trust. `uv tool install` instead puts the tool under `UV_TOOL_DIR` — a path we choose — and `uv
+ * tool list` (run with the same env) describes it completely.
  *
  * ## Measured evidence (2026-09-05, uv 0.11.5, macOS aarch64) — this is what the parsing below is
  * built on, not a guess
@@ -68,48 +65,41 @@
  * (true for `httpie` among its three); otherwise **neither** — this refuses rather than guesses.
  * uv's listing order is stable on one machine but not a documented contract, this path has never
  * been exercised against either real registry package, and a wrong guess here launches the wrong
- * binary silently, which is worse than a refusal a caller can act on. See {@link uvToolEntrypoint}
+ * binary silently, which is worse than a refusal a caller can act on. See {@link uvToolEntrypointFrom}
  * for the resulting three-outcome contract.
+ *
+ * ## Re-measured for per-build dirs (2026-10-11, uv 0.12.23, macOS aarch64, local wheel)
+ *
+ * With `UV_TOOL_DIR=<b>/tools UV_TOOL_BIN_DIR=<b>/bin`, `uv tool install` writes only under `<b>`
+ * (plus uv's download cache): the entry script's shebang is `<b>/tools/<pkg>/bin/python` (absolute),
+ * `<b>/bin/<exe>` is an absolute symlink to it, and `uv-receipt.toml` records both. A tree renamed
+ * after install therefore does not run — which is why uv builds are installed in place under a
+ * completion marker rather than staged and renamed (`builds/model.ts`).
  */
 import { runTimedCommand } from './timedCommand.js';
-/**
- * Wall-clock budget for one `uv tool list` / `uv tool dir` read — a local, no-network directory
- * probe, not a download. "A few seconds is generous" for that: 10s leaves ample headroom above
- * every measured run (low tens of milliseconds — see this module's own doc comment) while still
- * keeping a genuinely stuck `uv` (a broken shim, a filesystem wedged mid-fsck) from parking
- * `AcpAgents.roster` or a launch indefinitely.
- */
+/** Wall-clock budget for one `uv tool list` — a local, no-network directory read, not a download. */
 export const UV_PROBE_TIMEOUT_MS = 10_000;
 /**
- * Wall-clock budget for one `uv tool install <spec>` — a real package download, not a probe.
- *
- * Matches `installProbe.ts`'s `ADAPTER_INSTALL_TIMEOUT_MS` and `binaryInstall.ts`'s
- * `ARCHIVE_DOWNLOAD_TIMEOUT_MS` deliberately, for the same reason `binaryInstall.ts`'s own constant
- * gives for matching the first of those: this is the third of three siblings (npx, binary archive,
- * uvx tool) fetching a whole ACP adapter over the network, and there is no reason the one added
- * last should time out sooner than the other two just because it arrived later.
+ * Wall-clock budget for one `uv tool install <spec>` — a real package download, not a probe. Matches
+ * the npm and binary adapter install budgets: there is no reason the third sibling should time out sooner.
  */
 export const UV_TOOL_INSTALL_TIMEOUT_MS = 300_000;
 /**
- * Default `RunUv`: runs `uv <args>` through {@link runTimedCommand} (never `execFileSync`, see this
- * type's own doc comment), with every failure — a non-zero exit, `uv` not being on `PATH` at all
- * (`ENOENT`), or the run exceeding `timeoutMs` — folded into `{ ok: false }` rather than thrown. A
- * machine without `uv` installed is a normal machine, not an error condition this module gets to
- * raise; a `uv` that hangs past its budget is reported with a message naming the command and the
- * budget, not silently swallowed.
+ * Default `RunUv`: runs `uv <args>` through {@link runTimedCommand}, with every failure — a non-zero
+ * exit, `uv` not being on `PATH` at all (`ENOENT`), or the run exceeding `timeoutMs` — folded into
+ * `{ ok: false }` rather than thrown. A machine without `uv` is a normal machine.
  */
-async function defaultRunUv(args, timeoutMs) {
-    const result = await runTimedCommand('uv', args, timeoutMs);
+export async function defaultRunUv(args, timeoutMs, env) {
+    const result = await runTimedCommand('uv', args, timeoutMs, env ? { env: { ...process.env, ...env } } : {});
     if (result.ok)
         return { ok: true, stdout: result.stdout };
-    return { ok: false, stdout: '', error: result.message };
+    return { ok: false, stdout: '', error: result.message, ...(result.code ? { code: result.code } : {}) };
 }
 /**
  * Parses `uv tool list --show-paths` output (also tolerates the plain `uv tool list` form, with no
- * `(<path>)` suffixes, which is what makes the fixtures above double as fixtures for both). A tool
- * header line reads `<name> vX.Y.Z` or `<name> vX.Y.Z (<tool dir>)`; each executable line under it
- * reads `- <name>` or `- <name> (<absolute path>)`. `No tools installed` (uv's output for an empty
- * roster) matches neither pattern and yields no entries, which is the correct answer.
+ * `(<path>)` suffixes). A tool header line reads `<name> vX.Y.Z` or `<name> vX.Y.Z (<tool dir>)`; each
+ * executable line under it reads `- <name>` or `- <name> (<absolute path>)`. `No tools installed`
+ * matches neither pattern and yields no entries, which is the correct answer.
  */
 function parseToolList(stdout) {
     const entries = [];
@@ -132,117 +122,77 @@ function parseToolList(stdout) {
     return entries;
 }
 /**
- * One `uv tool list --show-paths` snapshot, parsed. This is the single place that actually spawns
- * `uv` for the "what's installed" question — {@link findTool} delegates to it rather than shelling
- * out itself, and `AcpAgents.roster` calls it directly, exactly **once per roster build**, so it can
- * look every uvx-distributed agent up in one snapshot instead of spawning `uv` again per agent (see
- * that call site's own doc comment for why a per-agent spawn was a defect worth hoisting out of).
- * `uv` missing, failing, or timing out degrades to `[]` — "nothing installed" — the same as every
- * other reader of {@link RunUv} in this module; it never throws. `timeoutMs` defaults to
- * {@link UV_PROBE_TIMEOUT_MS} — this is the probe half of `RunUv`'s two budgets, never the
- * `uv tool install` one.
+ * One `uv tool list --show-paths` snapshot, parsed, of the tool dir `env` names (a build's own; see
+ * `builds/install/uv.ts`). `uv` missing, failing, or timing out degrades to `[]` — "nothing
+ * installed"; it never throws.
  */
-export async function listUvTools(run = defaultRunUv, timeoutMs = UV_PROBE_TIMEOUT_MS) {
-    const result = await run(['tool', 'list', '--show-paths'], timeoutMs);
+export async function listUvTools(run = defaultRunUv, timeoutMs = UV_PROBE_TIMEOUT_MS, env) {
+    const result = await (env ? run(['tool', 'list', '--show-paths'], timeoutMs, env) : run(['tool', 'list', '--show-paths'], timeoutMs));
     if (!result.ok)
         return [];
     return parseToolList(result.stdout);
 }
-function findToolIn(tools, pkg) {
-    return tools.find((entry) => entry.name === pkg);
+/** PEP 503 name comparison: `Fast_Agent.ACP` and `fast-agent-acp` are the same distribution. */
+function sameDistribution(a, b) {
+    const normal = (name) => name.toLowerCase().replace(/[-_.]+/g, '-');
+    return normal(a) === normal(b);
 }
-async function findTool(pkg, run) {
-    return findToolIn(await listUvTools(run), pkg);
+/** The tool entry for `pkg` in a {@link listUvTools} snapshot, by PEP 503 name. */
+export function findUvTool(tools, pkg) {
+    return tools.find((entry) => sameDistribution(entry.name, pkg));
 }
 /**
- * The version of `pkg` that `uv tool list` reports as installed, or `undefined` when it is not
- * installed, or when `uv` itself is missing, fails, or times out.
- */
-export async function uvToolVersion(pkg, run = defaultRunUv) {
-    return (await findTool(pkg, run))?.version;
-}
-/**
- * Picks `pkg`'s launchable executable — the one `resolveLaunch`'s uvx branch runs instead of
- * shelling out to `uvx <pkg>` — out of an already-parsed `uv tool list --show-paths` snapshot
- * ({@link listUvTools}).
- *
- * Three shapes, in order:
- * 1. Exactly one executable declared → that one, whatever it is named. One candidate is not a
- *    guess.
+ * Picks `pkg`'s launchable executable out of an already-parsed `uv tool list --show-paths` snapshot
+ * ({@link listUvTools}). Three shapes, in order:
+ * 1. Exactly one executable declared → that one, whatever it is named.
  * 2. Several declared, and one matches the package's own name (true for `httpie` among its three,
  *    measured) → that one.
- * 3. Several declared, none matching → **refuse** (`ambiguous`, carrying every candidate name).
- *    uv's listing order is stable on one machine but is not a documented contract (see the module
- *    docstring), and this path has never been exercised against a real uvx-distributed agent —
- *    installing `fast-agent-acp`/`minion-code` to find out was ruled out of scope for this task.
- *    Guessing the first one and launching it would trade a diagnosable refusal for an ACP handshake
- *    that hangs or fails for a reason nobody can trace back to this choice, so this reports the
- *    ambiguity instead of resolving it.
- *
- * `not-installed` also covers: no such tool in `uv tool list`, `uv` itself missing or failing, a
- * matched executable whose recorded path is empty (the plain, no-`--show-paths` form this also
- * parses carries no paths at all) — none of these are launchable either, and none of them are
- * ambiguous the way case 3 is.
- *
- * Takes the parsed listing rather than a runner on purpose: a caller that already read
- * `uv tool list` once (`AcpAgents.roster`, so 39 registry entries share one spawn) hands that
- * result straight in here instead of this function spawning `uv` again per package. {@link
- * uvToolEntrypoint} is the thin wrapper for the one real caller (the actual launch path) that has
- * no such snapshot yet and needs to read it fresh.
+ * 3. Several declared, none matching → **refuse** (`ambiguous`, carrying every candidate name). uv's
+ *    listing order is not a documented contract, and a wrong guess launches the wrong binary silently.
+ *
+ * `not-installed` also covers a matched executable whose recorded path is empty (the plain,
+ * no-`--show-paths` form carries no paths at all).
  */
 export function uvToolEntrypointFrom(pkg, tools) {
-    const entry = findToolIn(tools, pkg);
+    const entry = findUvTool(tools, pkg);
     if (!entry || entry.executables.length === 0)
         return { ok: false, reason: 'not-installed' };
     if (entry.executables.length === 1) {
         const [only] = entry.executables;
         return only.path ? { ok: true, path: only.path } : { ok: false, reason: 'not-installed' };
     }
-    const match = entry.executables.find((exe) => exe.name === pkg);
+    const match = entry.executables.find((exe) => sameDistribution(exe.name, pkg));
     if (match) {
         return match.path ? { ok: true, path: match.path } : { ok: false, reason: 'not-installed' };
     }
     return { ok: false, reason: 'ambiguous', candidates: entry.executables.map((exe) => exe.name) };
 }
 /**
- * `uvToolEntrypointFrom`, but reading `uv tool list --show-paths` itself first — the real launch
- * path's entry point (`resolveLaunch`'s uvx branch with no pre-fetched listing), where doing its
- * own `uv` lookup at connect time is correct and expected, unlike the roster path (see {@link
- * uvToolEntrypointFrom}'s doc comment).
+ * Parses a registry `uvx.package` specifier. Both pins the live registry uses are understood —
+ * `fast-agent-acp==0.10.1` and `minion-code@0.1.44` (`uvx`'s `pkg@version` form). Anything else after
+ * the name (a range, a URL) is not a pin this layer can name a build after, and is refused.
  */
-export async function uvToolEntrypoint(pkg, run = defaultRunUv) {
-    return uvToolEntrypointFrom(pkg, await listUvTools(run));
+export function parseUvxSpec(spec) {
+    const match = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)(\[[A-Za-z0-9._,\s-]*\])?\s*(?:(?:==|@)\s*([A-Za-z0-9][A-Za-z0-9.+_-]*))?\s*$/.exec(spec);
+    if (!match)
+        throw new Error(`Unsupported uvx package specifier '${spec}'`);
+    return { name: match[1], extras: (match[2] ?? '').replace(/\s+/g, ''), ...(match[3] ? { version: match[3] } : {}) };
 }
-/**
- * The package name half of a `uv tool install` specifier: `pkg==1.2.3` → `pkg`. Returns the input
- * unchanged when it carries no `==` pin — the ACP registry is not required to pin `uvx` specifiers
- * the way it pins `npx` ones (see `registryTypes.ts`'s `UvxDistribution`).
- */
+/** The package name half of a uvx specifier: `pkg==1.2.3` / `pkg@1.2.3` / `pkg[x]` → `pkg`. Unparseable input is returned unchanged. */
 export function uvPackageName(spec) {
-    const at = spec.indexOf('==');
-    return at > 0 ? spec.slice(0, at) : spec;
+    try {
+        return parseUvxSpec(spec).name;
+    }
+    catch {
+        return spec;
+    }
 }
-/** The version half of a `uv tool install` specifier: `pkg==1.2.3` → `1.2.3`; `undefined` with no pin. */
+/** The version half of a uvx specifier: `pkg==1.2.3` / `pkg@1.2.3` → `1.2.3`; `undefined` with no pin. */
 export function uvPackageVersion(spec) {
-    const at = spec.indexOf('==');
-    return at > 0 ? spec.slice(at + 2) : undefined;
-}
-/**
- * `uv tool install <spec>` — the uvx counterpart to `installNpxPackage`. Short-circuits to
- * `alreadyInstalled: true` without spawning `uv tool install` when a quick `uv tool list` probe
- * (bounded by {@link UV_PROBE_TIMEOUT_MS}) already reports the pinned version — the same "don't
- * repeat work that's already done" rule `installNpxPackage` follows against the npx cache. The
- * actual install, when it runs, is a real download and gets {@link UV_TOOL_INSTALL_TIMEOUT_MS}, not
- * the probe's budget.
- */
-export async function installUvTool(spec, run = defaultRunUv) {
-    const pkg = uvPackageName(spec);
-    const pinned = uvPackageVersion(spec);
-    if (pinned && (await uvToolVersion(pkg, run)) === pinned) {
-        return { ok: true, alreadyInstalled: true };
+    try {
+        return parseUvxSpec(spec).version;
+    }
+    catch {
+        return undefined;
     }
-    const result = await run(['tool', 'install', spec], UV_TOOL_INSTALL_TIMEOUT_MS);
-    if (result.ok)
-        return { ok: true, alreadyInstalled: false };
-    return { ok: false, error: result.error ?? `uv tool install ${spec} failed` };
 }

package/dist/workstation/acp/validate.js

@@ -18,10 +18,13 @@
  * question. Its two wire names behave differently here, and the difference is the suffix, not the
  * family:
  *
- * - `elicitation_request` (`TimelineEvent.InteractionRequested`) is request-shaped and absent from
- *   the set, so a bridge emitting it is rejected. That stays true after Plan B minted the name:
- *   the platform now *has* the vocabulary but still has no bridge decode branch for it, so it still
- *   cannot answer one. Adding it here would exempt it into a generic item — a card with no button.
+ * - `elicitation_request` (`TimelineEvent.ElicitationRequested`) is request-shaped and, since the
+ *   platform grew a named decode branch for it (`TimelineEventWire.decodeElicitationRequested`,
+ *   landing a `WorkItemKind.USER_INTERACTION` item that parks the run), is now a member of this
+ *   set: a bridge emitting it is answerable, not rejected. The reply that unblocks the agent's
+ *   `elicitation/create` travels back on its own frame — `AgentFrame.AgentElicitationAnswer` — not
+ *   through `permission_request`'s `agent_answer`, because ACP's `CreateElicitationResponse.content`
+ *   is a structured object `agent_answer`'s single-string `outcome` cannot carry.
  * - `elicitation` (`TimelineEvent.UserInteractionRequested`) carries no request suffix, so this gate
  *   never looks at it and a bridge emitting it passes through. That is now correct rather than
  *   merely harmless: `TimelineEventWire.decode` has a named `elicitation` branch that rebuilds the
@@ -32,7 +35,7 @@
  *   run never parks on. Well-formedness is defined in exactly one place, that decoder; this gate
  *   deliberately does not carry a second copy of the shape rules to drift from it.
  */
-export const KNOWN_REQUEST_EVENT_NAMES = new Set(['permission_request']);
+export const KNOWN_REQUEST_EVENT_NAMES = new Set(['permission_request', 'elicitation_request']);
 /**
  * Does this name carry the "answer me exactly once" promise?
  *
@@ -130,5 +133,30 @@ function inspect(event) {
             }
         }
     }
+    // `elicitation_request`'s counterpart to the `permission_request` checks above — added by Task 18,
+    // which is also this event's first real producer (`permission.ts`'s `handleFormElicitation`).
+    // `validate.test.ts` used to pin the opposite — `{requestId: 'r1'}` alone passing — on the explicit
+    // reasoning that a shape rule with no producer to catch would only be guarding against a caller
+    // that did not exist; that premise no longer holds, so the rule now exists too. `mode`/`message` are
+    // the two fields `elicitationRequestFromPayload` (`ElicitationRequest.kt`) requires no matter which
+    // mode arrives — a payload missing either is dropped silently server-side (`runCatching { ... }
+    // .getOrNull()`), the same "advisory here, silent there" gap the `permission_request` checks above
+    // exist to close.
+    if (event.eventName === 'elicitation_request') {
+        if (!nonEmptyString(payload.requestId)) {
+            return { reason: 'invalid elicitation_request', detail: 'requestId must be a non-empty string' };
+        }
+        const request = payload.request;
+        if (request === null || typeof request !== 'object' || Array.isArray(request)) {
+            return { reason: 'invalid elicitation_request', detail: 'request must be an object' };
+        }
+        const requestPayload = request;
+        if (!nonEmptyString(requestPayload.mode)) {
+            return { reason: 'invalid elicitation_request', detail: 'request.mode must be a non-empty string' };
+        }
+        if (!nonEmptyString(requestPayload.message)) {
+            return { reason: 'invalid elicitation_request', detail: 'request.message must be a non-empty string' };
+        }
+    }
     return null;
 }

package/dist/workstation/agentFlow.js

@@ -0,0 +1,103 @@
+/**
+ * The agent channel's global socket gate (Task 20, spec 2026-10-11 §5.6; `desktop/bridge.ts` is the precedent).
+ *
+ * Session frames are sent only while the encrypted socket's `bufferedAmount` is below {@link SOCKET_HIGH_WATER_BYTES}; once it
+ * reaches that, they wait until it has drained to {@link SOCKET_LOW_WATER_BYTES}. The channel's heartbeat is written straight to
+ * the same socket by the channel itself, so what this bounds is how much it can find queued ahead of it: about 1 MiB plus one
+ * frame instead of everything a talkative agent produced — on a slow link, seconds instead of minutes, and a heartbeat that misses
+ * its ack closes the channel.
+ *
+ * What goes through the gate, and what does not (B §4.3/§5):
+ *
+ * - **session frames** (`agent_event`, `agent_turn_done`: numbered, recorded in the outbox, acknowledged by the server) wait for
+ *   the gate **and** their session's window (`acp/outbox.ts`). `agent_turn_done` is one of them, not a control frame: the server
+ *   moves `lastSeenSeq` on it, so letting it overtake lower-seq events would make the server drop them as duplicates;
+ * - **subagent relations** (`agent_event{eventName:'subagent_spawned'}`, the server's `SubagentSpawned`) that resolve a child
+ *   frame recorded before them bypass the session window — with the frames before them, in seq order — but not the gate: the
+ *   server caps its acks below the first child frame still waiting for its relation (`ExternalAgentEventApplier.noteApplied`,
+ *   `nativePendingBefore - 1`), so a window that held the relation back would wait for an ack that cannot come (the server
+ *   poisons after 30 s and every reopen repeats it). Mechanism and the producing side: `acp/outbox.ts`;
+ * - **bulk unnumbered** frames (`agent_backfill_events`) wait for the gate only — they are never acknowledged, so no session
+ *   window could ever open for them;
+ * - **control frames** bypass both and are written at once: RPC replies (`agent_opened`, `agent_steered`,
+ *   `agent_config_option_set`, `agent_native_sessions`, `agent_native_deleted`, `agent_verified`, `agent_authenticated`,
+ *   `agent_installed`, `agent_delegation_renewed`, `agent_provider_task_stopped`, `agent_backfill_done`), levels
+ *   (`agent_session_state`, `agent_runtime_profile`, `agent_provider_task_event`), `agent_session_lost`, `agent_resume_offer`,
+ *   `agent_auth_url`/`agent_auth_done`, and the channel's own heartbeat. They are small and rare, an answer the server is waiting
+ *   for (a 10–120 s timeout) must not queue behind a session's backlog, and an answer to a user (a permission card's state) must
+ *   not wait for the window that answer is about to open. They still count against the gate: they add to `bufferedAmount`, which
+ *   session frames then wait on.
+ */
+/** Session frames stop once the socket holds this much unsent (spec §5.6). */
+export const SOCKET_HIGH_WATER_BYTES = 1024 * 1024;
+/** …and resume once it has drained to this (spec §5.6). */
+export const SOCKET_LOW_WATER_BYTES = 256 * 1024;
+/** How often a closed gate looks at the socket again. */
+export const SOCKET_POLL_MS = 25;
+export class SocketGate {
+    bufferedAmount;
+    closed = false;
+    timer;
+    waiters = new Set();
+    /** `bufferedAmount` of the bound socket; `undefined`: no socket to measure (the gate stays open). */
+    constructor(bufferedAmount = undefined) {
+        this.bufferedAmount = bufferedAmount;
+    }
+    /** A new connection (or none): its own buffer; whatever waited is woken to look again. */
+    rebind(bufferedAmount) {
+        this.bufferedAmount = bufferedAmount;
+        this.closed = false;
+        this.wake();
+    }
+    /** May a session frame be written now? Closes at the high water mark, reopens at the low one. */
+    isOpen() {
+        const buffered = this.bufferedAmount?.() ?? 0;
+        if (this.closed) {
+            if (buffered > SOCKET_LOW_WATER_BYTES)
+                return false;
+            this.closed = false;
+            return true;
+        }
+        if (buffered >= SOCKET_HIGH_WATER_BYTES) {
+            this.closed = true;
+            return false;
+        }
+        return true;
+    }
+    /** Calls `then` once the gate is open again (polling the socket while it is closed). */
+    whenOpen(then) {
+        this.waiters.add(then);
+        this.poll();
+    }
+    /** Resolves when the gate is open. */
+    opened() {
+        if (this.isOpen())
+            return Promise.resolve();
+        return new Promise((resolve) => this.whenOpen(resolve));
+    }
+    poll() {
+        if (this.timer || this.waiters.size === 0)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            if (this.isOpen())
+                this.wake();
+            else
+                this.poll();
+        }, SOCKET_POLL_MS);
+        this.timer.unref?.();
+    }
+    wake() {
+        const waiters = [...this.waiters];
+        this.waiters.clear();
+        for (const waiter of waiters)
+            waiter();
+    }
+    /** Stops polling (daemon shutdown). Waiters are dropped. */
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        this.waiters.clear();
+    }
+}