@nelsonlongxiang/dsh-open-a2a-net 0.5.14 → 0.6.24

package/nexus-stage/src/fault.ts

@@ -0,0 +1,56 @@
+/**
+ * The stage's fault surface as pure logic: whoever calls {@link fault}
+ * gets the newest message on the sink immediately, while the diagnostic
+ * log line is throttled to one per window (the N2 breadcrumb cadence).
+ * {@link clear} hides the sink and resets the throttle clock, so the first
+ * fault after a healthy stretch logs promptly again.
+ *
+ * DOM-free on purpose: the browser shell in main.ts supplies the sink, and
+ * the unit test supplies fakes — the lifecycle (sink-always-current,
+ * log-throttled, clear-resets) is what the regression net owns. This module
+ * exists because the incident class it guards against (a catch burying a
+ * ReferenceError behind a healthy render loop) shipped once already.
+ * @module nexus-stage/fault
+ */
+
+/** How long one diagnostic log line suppresses its successors. */
+export const FAULT_LOG_THROTTLE_MS = 60_000
+
+/** Anything the fault reporter can render onto. */
+export interface FaultSink {
+  /** Surface the newest fault; the sink becomes visible with this text. */
+  show(message: string): void
+  /** Retract the sink after a healthy response. */
+  hide(): void
+}
+
+export interface FaultReporter {
+  /** Surface a fault: the sink always updates, the log line throttles. */
+  fault(message: string): void
+  /** A healthy response arrived: hide the sink and reset the throttle. */
+  clear(): void
+}
+
+/**
+ * @param sink - render target (DOM badge in the shell, recording fake in tests).
+ * @param log - diagnostic channel (console.error in the shell, spy in tests).
+ * @param now - injectable clock for deterministic throttle tests. A fault
+ *   exactly one window after the previous logs again (window is inclusive).
+ */
+export function createFaultReporter(sink: FaultSink, log: (message: string) => void, now: () => number = Date.now): FaultReporter {
+  let lastLoggedAt = -FAULT_LOG_THROTTLE_MS
+  return {
+    fault(message) {
+      const at = now()
+      if (at - lastLoggedAt >= FAULT_LOG_THROTTLE_MS) {
+        log(`[nexus] ${message}`)
+        lastLoggedAt = at
+      }
+      sink.show(message)
+    },
+    clear() {
+      sink.hide()
+      lastLoggedAt = -FAULT_LOG_THROTTLE_MS
+    },
+  }
+}

package/nexus-stage/src/federation.ts

@@ -0,0 +1,234 @@
+/**
+ * Federation overlay geometry for the 2D planning canvas (PR D 活动/联邦
+ * 层): where peer badges sit, which accent edges carry the pending a2a
+ * routes, and where the indigo federal referral lines attach. Everything
+ * is derived from the polling state (`/__dsh_a2a/state` -> inFlight,
+ * peers) plus the team-frame anchors, so the DOM layer only draws what
+ * these functions return - same derivation discipline as edges.ts.
+ *
+ * Pure: no DOM, no three, no clock. `now` is always a parameter so the
+ * suite pins time deterministically. All coordinates are world-space;
+ * the transformed #world container carries them to the screen for free.
+ * @module nexus-stage/federation
+ */
+
+import type { WorldBounds } from './viewport'
+
+/** One pending outbound route from /state `inFlight`. */
+export interface InFlightRow {
+  team: string
+  /** peer as `host:port` (no scheme) - the badge url carries the scheme. */
+  peer: string
+  startedAt: number
+}
+
+/** One federation peer from /state `peers`. */
+export interface PeerRow {
+  url: string
+  score?: number
+}
+
+/** A team frame's titlebar anchor {fx + fw/2, fy + 11} (edges.ts lockstep). */
+export interface FrameAnchor {
+  name: string
+  x: number
+  y: number
+}
+
+/** A peer badge's resolved slot in the placement column. */
+export interface PeerPlacement {
+  url: string
+  score?: number
+  x: number
+  y: number
+}
+
+/** One derived overlay edge, ready for the SVG / label layers. */
+/** Node id for a peer endpoint: `peer-<host>:<port>` (≤128, no '/').
+ *  Unparseable urls keep their raw text, reduced to id-safe characters —
+ *  attacker-shaped urls collapse to one id instead of poisoning selectors. */
+export function peerNodeId(url: string): string {
+  const host = peerHostOf(url).replace(/[^A-Za-z0-9.:\[\]-]/g, '-')
+  return `peer-${host}`
+}
+
+/** Bare host:port of a peer url (scheme stripped; unparseable urls pass through). */
+export function peerHostOf(url: string): string {
+  try {
+    return new URL(url).host
+  } catch {
+    return url
+  }
+}
+
+/** One remote team row as the directory reports it (state.remote). */
+export interface RemoteTeamRow {
+  team: string
+  name?: string
+  via?: string
+  workspace?: string
+  /** Publishing node's label + LAN IP — the host grouping dimension. */
+  origin?: string
+  /** Roster teams the publishing node declared for this handle (card teamMemberships). */
+  teams?: readonly string[]
+}
+
+/**
+ * Group remote team rows by the peer endpoint they arrived through. Rows
+ * without a usable `via` land under '' (skipped by peer card rendering).
+ * Key = bare host:port.
+ */
+export function groupRemoteTeams(rows: ReadonlyArray<RemoteTeamRow>): Map<string, RemoteTeamRow[]> {
+  const out = new Map<string, RemoteTeamRow[]>()
+  for (const row of rows) {
+    const via = row.via !== undefined && row.via !== '' ? peerHostOf(row.via) : ''
+    const list = out.get(via) ?? []
+    list.push(row)
+    out.set(via, list)
+  }
+  return out
+}
+
+export interface ActivityEdge {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+  label: string
+}
+
+/** Badge column x-offset right of the frames' content bounds (maxX + gap). */
+export const PEER_COLUMN_GAP = 140
+/** Fallback column x while the canvas has no frames to anchor against. */
+export const PEER_COLUMN_FALLBACK_X = 200
+/** Vertical pitch between badges in the column. */
+export const PEER_COLUMN_STEP = 90
+/** Federal-line origin gap left of the content bounds (minX - gap). */
+/** Fallback federal anchor offset (null bounds): x = -GAP. */
+export const FEDERAL_ANCHOR_GAP = 80
+/** Gutter gap between the card field's right edge and the federal anchor
+ *  (bounds.maxX + GUTTER) — keeps the short stubs off the card field. */
+export const FEDERAL_GUTTER_GAP = 20
+/** Padding around every badge point when computing the fly region. */
+export const FLY_PAD = 60
+
+/**
+ * Lay the peer badges out in a deterministic column: one x for all,
+ * y stacked from the content bounds' top at a fixed 90px pitch, in the
+ * peers array's order. Recomputed every reconcile - the column tracks
+ * the content, never the mouse. Null bounds (empty canvas) fall back to
+ * a fixed origin so first paint is still deterministic.
+ */
+export function placePeers(
+  peers: ReadonlyArray<PeerRow>,
+  bounds: WorldBounds | null,
+): PeerPlacement[] {
+  const x = bounds !== null ? bounds.maxX + PEER_COLUMN_GAP : PEER_COLUMN_FALLBACK_X
+  const y0 = bounds !== null ? bounds.minY : 0
+  return peers.map((peer, i) => ({
+    url: peer.url,
+    score: peer.score,
+    x,
+    y: y0 + i * PEER_COLUMN_STEP,
+  }))
+}
+
+/**
+ * One accent edge per pending outbound route: from the route's team
+ * frame titlebar anchor to the matching peer badge, labelled with the
+ * route and its whole-second age. Rows whose team has no frame or whose
+ * peer matches no badge are skipped - dangling rows are a polling
+ * transient, not an error. Peer match is by suffix (`host:port` against
+ * `scheme://host:port`), first badge in array order wins.
+ */
+export function activityEdges(
+  inFlight: ReadonlyArray<InFlightRow>,
+  anchors: ReadonlyMap<string, FrameAnchor>,
+  peers: ReadonlyArray<PeerPlacement>,
+  now: number,
+): ActivityEdge[] {
+  // Merge identical (team, peer) routes into ONE edge: N concurrent routes
+  // over the same span would stack perfectly opaque duplicates. The label
+  // counts them (×N) and reports the OLDEST route's age — the one the user
+  // has been waiting on longest.
+  const merged = new Map<string, { team: string; peer: string; startedAt: number; count: number }>()
+  for (const row of inFlight) {
+    if (!anchors.has(row.team)) continue
+    const key = `${row.team}\u0000${row.peer}`
+    const cur = merged.get(key)
+    if (cur === undefined) merged.set(key, { team: row.team, peer: row.peer, startedAt: row.startedAt, count: 1 })
+    else {
+      cur.startedAt = Math.min(cur.startedAt, row.startedAt)
+      cur.count += 1
+    }
+  }
+
+  const out: ActivityEdge[] = []
+  for (const g of merged.values()) {
+    const anchor = anchors.get(g.team)
+    if (anchor === undefined) continue
+    // Match by parsed host:port — a bare endsWith would let 'badhost:port'
+    // satisfy a 'host:port' route.
+    const badge = peers.find(p => { try { return new URL(p.url).host === g.peer } catch { return false } })
+    if (badge === undefined) continue
+    const elapsed = Math.max(0, Math.round((now - g.startedAt) / 1000))
+    out.push({
+      x1: anchor.x,
+      y1: anchor.y,
+      x2: badge.x,
+      y2: badge.y,
+      label: `a2a_route · ${g.peer} · ${elapsed}s` + (g.count > 1 ? ` ×${g.count}` : ''),
+    })
+  }
+  return out
+}
+
+/**
+ * Federal referral lines: from a content-bounds anchor (minX - 80,
+ * vertical center) out to every peer badge. Only the first line is
+ * labelled "gns referral" - one legend row, not one label per peer.
+ * Null bounds anchors the fan at the fixed fallback origin.
+ */
+export function federalEdges(
+  peers: ReadonlyArray<PeerPlacement>,
+  bounds: WorldBounds | null,
+): ActivityEdge[] {
+  // Gutter anchor: between the card field's right edge and the badge column,
+  // at the badges' vertical mid — short stubs that cannot cross any card
+  // (an anchor at the content's left middle raked long diagonals through
+  // the whole field: the reported wiring anomaly).
+  const anchor = bounds !== null
+    ? { x: bounds.maxX + FEDERAL_GUTTER_GAP, y: peers.length > 0 ? (peers[0]!.y + peers[peers.length - 1]!.y) / 2 : (bounds.minY + bounds.maxY) / 2 }
+    : { x: -FEDERAL_ANCHOR_GAP, y: 0 }
+  return peers.map((peer, i) => ({
+    x1: anchor.x,
+    y1: anchor.y,
+    x2: peer.x,
+    y2: peer.y,
+    label: i === 0 ? 'gns referral' : '',
+  }))
+}
+
+/**
+ * The fly region: frames' content bounds unioned with every badge point
+ * padded by FLY_PAD, so a fit over it frames the whole federation
+ * (canvas + column) with breathing room. Null only when there is
+ * nothing at all to fly to.
+ */
+export function flyBounds(
+  bounds: WorldBounds | null,
+  peers: ReadonlyArray<PeerPlacement>,
+): WorldBounds | null {
+  if (bounds === null && peers.length === 0) return null
+  let minX = bounds !== null ? bounds.minX : Number.POSITIVE_INFINITY
+  let minY = bounds !== null ? bounds.minY : Number.POSITIVE_INFINITY
+  let maxX = bounds !== null ? bounds.maxX : Number.NEGATIVE_INFINITY
+  let maxY = bounds !== null ? bounds.maxY : Number.NEGATIVE_INFINITY
+  for (const peer of peers) {
+    minX = Math.min(minX, peer.x - FLY_PAD)
+    minY = Math.min(minY, peer.y - FLY_PAD)
+    maxX = Math.max(maxX, peer.x + FLY_PAD)
+    maxY = Math.max(maxY, peer.y + FLY_PAD)
+  }
+  return { minX, minY, maxX, maxY }
+}

package/nexus-stage/src/layout-doc.ts

@@ -0,0 +1,143 @@
+/**
+ * Client-side mirror of the host layout contract (src/layout-store.ts).
+ * The host module imports node:fs, so the stage cannot share its types -
+ * this file redeclares the v1 document shape and reimplements the exact
+ * clamp discipline. Parity is not optional: the save loop adopts the
+ * host's normalized response, and a mirror that clamped differently from
+ * the host would make every save look like an external edit and keep the
+ * save lamp pending forever. The clamp vectors in tests/planning-world.spec.ts
+ * pin both sides to the same answers.
+ *
+ * Zero dependencies, no DOM - unit-testable straight from the root suite.
+ * @module nexus-stage/layout-doc
+ */
+
+/** One draggable point in world space. */
+export interface LayoutPoint { readonly x: number; readonly y: number }
+
+/** One team-frame rectangle in world space. */
+export interface LayoutRect extends LayoutPoint { readonly w: number; readonly h: number }
+
+/** The viewport transform (world point at the top-left corner, plus zoom). */
+export interface LayoutViewport extends LayoutPoint { readonly scale: number }
+
+/** The whole persisted document (v1). */
+export interface LayoutDoc {
+  readonly version: 1
+  readonly viewport: LayoutViewport
+  readonly nodes: Readonly<Record<string, LayoutPoint>>
+  readonly frames: Readonly<Record<string, LayoutRect>>
+}
+
+/** World-coordinate magnitude bound: values beyond are clamped, never trusted. */
+export const COORD_LIMIT = 1_000_000
+/** Zoom bounds, matching the page's wheel clamps. */
+export const SCALE_MIN = 0.25
+export const SCALE_MAX = 3
+/** Document shape caps: a layout taxonomy, not a database. */
+export const LAYOUT_NODE_CAP = 256
+export const LAYOUT_FRAME_CAP = 96
+
+function clampCoord(v: unknown): number | undefined {
+  const n = typeof v === 'number' ? v : Number.NaN
+  if (!Number.isFinite(n)) return undefined
+  return Math.max(-COORD_LIMIT, Math.min(COORD_LIMIT, Math.round(n)))
+}
+
+function clampPoint(raw: unknown): LayoutPoint | undefined {
+  if (raw === null || typeof raw !== 'object') return undefined
+  const rec = raw as Record<string, unknown>
+  const x = clampCoord(rec.x)
+  const y = clampCoord(rec.y)
+  return x === undefined || y === undefined ? undefined : { x, y }
+}
+
+function clampRect(raw: unknown): LayoutRect | undefined {
+  const point = clampPoint(raw)
+  if (point === undefined) return undefined
+  const rec = raw as Record<string, unknown>
+  const w = clampCoord(rec.w)
+  const h = clampCoord(rec.h)
+  if (w === undefined || h === undefined || w <= 0 || h <= 0) return undefined
+  return { ...point, w: Math.min(w, COORD_LIMIT), h: Math.min(h, COORD_LIMIT) }
+}
+
+/**
+ * Normalize an untrusted layout document exactly as the host does:
+ * version!==1 rejects the whole doc; non-finite coordinates drop the
+ * point; coordinates round and clamp to ±COORD_LIMIT; scale clamps to
+ * [SCALE_MIN, SCALE_MAX]; node keys cap at 128 chars; frame keys mirror
+ * canvas team names (no '/', cap 40); rects need w>0 and h>0; caps are
+ * first-wins in insertion order - entries beyond are silently dropped,
+ * never refused (an overflow renders, it just does not persist).
+ */
+export function clampDoc(raw: unknown): LayoutDoc | undefined {
+  if (raw === null || typeof raw !== 'object') return undefined
+  const rec = raw as Record<string, unknown>
+  if (rec.version !== 1) return undefined
+  const vpRaw = rec.viewport
+  if (vpRaw === null || typeof vpRaw !== 'object') return undefined
+  const vp = vpRaw as Record<string, unknown>
+  const vx = clampCoord(vp.x)
+  const vy = clampCoord(vp.y)
+  const vsRaw = vp.scale
+  const vsNum = typeof vsRaw === 'number' ? vsRaw : Number.NaN
+  if (vx === undefined || vy === undefined || !Number.isFinite(vsNum)) return undefined
+  const scale = Math.max(SCALE_MIN, Math.min(SCALE_MAX, vsNum))
+  const nodes: Record<string, LayoutPoint> = {}
+  if (rec.nodes !== null && typeof rec.nodes === 'object') {
+    for (const [id, point] of Object.entries(rec.nodes as Record<string, unknown>)) {
+      if (typeof id !== 'string' || id === '' || id.length > 128) continue
+      const p = clampPoint(point)
+      if (p !== undefined) nodes[id] = p
+      if (Object.keys(nodes).length >= LAYOUT_NODE_CAP) break
+    }
+  }
+  const frames: Record<string, LayoutRect> = {}
+  if (rec.frames !== null && typeof rec.frames === 'object') {
+    for (const [name, rect] of Object.entries(rec.frames as Record<string, unknown>)) {
+      if (typeof name !== 'string' || name === '' || name.includes('/') || name.length > 40) continue
+      const r = clampRect(rect)
+      if (r !== undefined) frames[name] = r
+      if (Object.keys(frames).length >= LAYOUT_FRAME_CAP) break
+    }
+  }
+  return { version: 1, viewport: { x: vx, y: vy, scale }, nodes, frames }
+}
+
+/**
+ * Build a save payload from trusted in-memory state. Pre-clamps with the
+ * same mirror discipline and truncates in roster insertion order, so the
+ * document we send is already the document the host will normalize to -
+ * the save response is then a fixpoint of our payload, which the save
+ * loop relies on to tell "our own save echoed back" from "someone else
+ * edited while the request was in flight".
+ */
+export function buildLayoutDoc(
+  viewport: LayoutViewport,
+  nodes: ReadonlyMap<string, LayoutPoint>,
+  frames: ReadonlyMap<string, LayoutRect>,
+): LayoutDoc {
+  const clamp = (n: number): number => Math.max(-COORD_LIMIT, Math.min(COORD_LIMIT, Math.round(n)))
+  const docNodes: Record<string, LayoutPoint> = {}
+  for (const [id, p] of nodes) {
+    if (typeof id !== 'string' || id === '' || id.length > 128) continue
+    docNodes[id] = { x: clamp(p.x), y: clamp(p.y) }
+    if (Object.keys(docNodes).length >= LAYOUT_NODE_CAP) break
+  }
+  const docFrames: Record<string, LayoutRect> = {}
+  for (const [name, r] of frames) {
+    if (typeof name !== 'string' || name === '' || name.includes('/') || name.length > 40) continue
+    const w = clamp(r.w)
+    const h = clamp(r.h)
+    if (w <= 0 || h <= 0) continue
+    docFrames[name] = { x: clamp(r.x), y: clamp(r.y), w: Math.min(w, COORD_LIMIT), h: Math.min(h, COORD_LIMIT) }
+    if (Object.keys(docFrames).length >= LAYOUT_FRAME_CAP) break
+  }
+  return {
+    version: 1,
+    viewport: { x: clamp(viewport.x), y: clamp(viewport.y), scale: Math.max(SCALE_MIN, Math.min(SCALE_MAX, viewport.scale)) },
+    nodes: docNodes,
+    frames: docFrames,
+  }
+}

package/nexus-stage/src/layout-wire.ts

@@ -0,0 +1,158 @@
+/**
+ * The planning canvas's layout save loop: debounce dirty flags into one
+ * POST, drive the save lamp (idle -> pending -> saved | error), and adopt
+ * the host's normalized snapshot without ever fighting an in-flight drag.
+ *
+ * Discipline (born of the review's "empty catch" incidents):
+ * - the payload is read at SEND time, so edits during the debounce window
+ *   ride the same request;
+ * - on success the sent document is compared against the live one - if
+ *   they differ, the user edited during flight: positions are NOT touched
+ *   (the live model is authoritative), the lamp stays pending, and the
+ *   loop chains the follow-up save. Only an unchanged document adopts the
+ *   host's normalized response, and because the client pre-clamps with
+ *   the host-mirror discipline, our own echo is byte-equal and adoption
+ *   is a no-op in the common case;
+ * - failures surface (lamp error + the stage's throttled fault reporter),
+ *   never swallowed - retry is explicit (click) or implicit (next edit).
+ *
+ * Pure control flow: the transport, the timer, and the clock are all
+ * injected, so tests pin the ladder without a network or real time.
+ * @module nexus-stage/layout-wire
+ */
+
+/** Save-lamp states: grey=start, amber=unsaved, green=stored, red=failed. */
+export type LampState = 'idle' | 'pending' | 'saved' | 'error'
+
+/** Debounce window collapsing nudge storms into one request. */
+export const SAVE_DEBOUNCE_MS = 800
+
+/** What send() must resolve to: the host's {ok, layout?, error?} body. */
+export interface SaveResponse { ok: boolean; layout?: unknown; error?: string }
+
+export interface SaveLoopDeps {
+  /** The current layout document, read at send time. */
+  snapshot(): unknown
+  /** POST the document; resolve with the parsed host body, throw on transport failure. */
+  send(doc: unknown, opts: { keepalive: boolean }): Promise<SaveResponse>
+  /** Timer injection: schedule(fn, ms) returns its cancel function. */
+  schedule(fn: () => void, ms: number): () => void
+  /** Injectable clock (reserved for throttle semantics parity with fault.ts). */
+  now(): number
+  /** Lamp transitions; never called with the same state twice in a row. */
+  onLamp(state: LampState): void
+  /** Adopt the host's normalized layout (only on unchanged-document success). */
+  onAdopt(layout: unknown): void
+  /** Transport/refusal failures, for the stage's fault surface. */
+  onHttpError(message: string): void
+}
+
+export interface SaveLoop {
+  /** Something moved: lamp pending, debounced save (re-)armed. */
+  markDirty(): void
+  /** Explicit retry after an error (lamp click). */
+  retry(): void
+  /** Fire now with keepalive - the pagehide path. */
+  flush(): void
+  /** True while a request is in flight. */
+  isBusy(): boolean
+  /** Cancel the armed timer; the loop stops. */
+  dispose(): void
+}
+
+/** Create the save loop over the given dependencies. */
+export function createSaveLoop(deps: SaveLoopDeps): SaveLoop {
+  let cancelTimer: (() => void) | undefined
+  let busy = false
+  let dirty = false
+  let flushAfterSettle = false
+  let lamp: LampState = 'idle'
+
+  function setLamp(next: LampState): void {
+    if (next === lamp) return
+    lamp = next
+    deps.onLamp(next)
+  }
+
+  function clearTimer(): void {
+    if (cancelTimer !== undefined) { cancelTimer(); cancelTimer = undefined }
+  }
+
+  function arm(): void {
+    clearTimer()
+    cancelTimer = deps.schedule(() => { cancelTimer = undefined; void fire(false) }, SAVE_DEBOUNCE_MS)
+  }
+
+  async function fire(keepalive: boolean): Promise<void> {
+    if (busy) { dirty = true; return }
+    busy = true
+    clearTimer()
+    const sent = deps.snapshot()
+    let sentJson: string
+    try {
+      sentJson = JSON.stringify(sent)
+    } catch {
+      busy = false
+      setLamp('error')
+      deps.onHttpError('layout document is not JSON-serializable')
+      return
+    }
+    try {
+      const res = await deps.send(sent, { keepalive })
+      if (res === null || typeof res !== 'object' || res.ok !== true) {
+        setLamp('error')
+        const reason = res !== null && typeof res === 'object' && typeof res.error === 'string' ? res.error : 'layout save refused'
+        deps.onHttpError(`layout save: ${reason}`)
+      } else if (JSON.stringify(deps.snapshot()) === sentJson) {
+        deps.onAdopt(res.layout)
+        setLamp('saved')
+      } else {
+        // Edited mid-flight: the live model stays authoritative; the dirty
+        // handling below chains the follow-up save.
+      }
+    } catch (error) {
+      setLamp('error')
+      deps.onHttpError(`layout save unreachable: ${String((error as Error | undefined)?.message ?? error).slice(0, 80)}`)
+    }
+    busy = false
+    if (lamp === 'error') {
+      // The flush request was consumed by the failed save: retry is
+      // explicit — do not let the stale flag chain an extra keepalive.
+      flushAfterSettle = false
+      return
+    }
+    // pagehide raced a busy save: the queued edits must not wait for a
+    // debounce that a closing page will never fire — flush immediately.
+    if (flushAfterSettle) {
+      flushAfterSettle = false
+      void fire(true)
+      return
+    }
+    if (dirty) {
+      dirty = false
+      setLamp('pending')
+      arm()
+    }
+  }
+
+  return {
+    markDirty() {
+      dirty = false
+      setLamp('pending')
+      if (busy) { dirty = true; return }
+      arm()
+    },
+    retry() {
+      if (lamp !== 'error' || busy) return
+      setLamp('pending')
+      void fire(false)
+    },
+    flush() {
+      if (busy) { flushAfterSettle = true; dirty = true; return }
+      clearTimer()
+      void fire(true)
+    },
+    isBusy() { return busy },
+    dispose() { clearTimer() },
+  }
+}