@zhuxixi/pi-agent-board 0.5.2 → 0.6.1

package/src/core/store.mjs

@@ -5,6 +5,8 @@
  */
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { atomicWriteJson, ensureDir, readJson } from "./atomic.mjs";
+import { sameHostOwner } from "./host-coordination.mjs";
+import { tryAcquireOwnedViewLock } from "./locks.mjs";
 import * as P from "./paths.mjs";
 import { isAlive } from "./pid.mjs";
 import { readCodeRefs, summarizeCodeRefs } from "./code-refs-store.mjs";
@@ -120,9 +122,159 @@ export function writeHost(root, host) {
 	atomicWriteJson(P.hostPath(root, host.viewId), host);
 }
 
-/** @param {string} root @param {string} viewId @param {number|null} pid */
-export function writeHostPid(root, viewId, pid) {
-	atomicWriteJson(P.hostPidPath(root, viewId), { pid, at: Date.now() });
+/**
+ * @param {string} root
+ * @param {string} viewId
+ * @param {number|null} pid
+ * @param {{ instanceId?: string, identity?: object|null }} [extra] merged into the mirror record
+ */
+export function writeHostPid(root, viewId, pid, extra) {
+	atomicWriteJson(P.hostPidPath(root, viewId), { pid, at: Date.now(), ...(extra ?? {}) });
+}
+
+/**
+ * Host states that represent an unreplaced claim: no replacement may be
+ * started while a host record is in one of these states (issue #70).
+ * @param {HostStatus|null} host
+ */
+function hostClaimActive(host) {
+	return Boolean(host && (host.state === "starting" || host.state === "alive" || host.state === "stopping"));
+}
+
+/**
+ * Atomically create the provisional `starting` host record for a new instance.
+ * The ONLY entry point allowed to move "no claim / reclaimable terminal state"
+ * into `starting` (issue #70). Refuses when an active claim exists or the
+ * host-meta lease is contended; the fresh record always nulls runner/child/
+ * ready/stop fields so no stale owner data survives the handover.
+ * @param {string} root
+ * @param {Partial<HostStatus> & { viewId: string, instanceId: string }} provisionalHost
+ * @param {{ heldStartLease?: unknown }} [opts] reserved for host-start lease nesting;
+ *   host-meta is always acquired independently here (short critical section).
+ * @returns {{ claimed: boolean, host: HostStatus|null }}
+ */
+export function claimHost(root, provisionalHost, opts = {}) {
+	const lock = tryAcquireOwnedViewLock(root, provisionalHost.viewId, "host-meta");
+	if (!lock.acquired) return { claimed: false, host: null };
+	try {
+		const existing = readHost(root, provisionalHost.viewId);
+		if (hostClaimActive(existing)) return { claimed: false, host: existing };
+		const now = Date.now();
+		/** @type {HostStatus} */
+		const record = {
+			version: 1,
+			viewId: provisionalHost.viewId,
+			mode: "pty",
+			instanceId: provisionalHost.instanceId,
+			configPath: provisionalHost.configPath ?? null,
+			socketPath: provisionalHost.socketPath ?? null,
+			claimAt: provisionalHost.claimAt ?? now,
+			claimPid: provisionalHost.claimPid ?? null,
+			claimIdentity: provisionalHost.claimIdentity ?? null,
+			// A fresh claim owns nothing yet: force-clear every field a superseded
+			// instance might have left behind.
+			runnerPid: null,
+			runnerIdentity: null,
+			runnerSpawnedAt: null,
+			childPid: null,
+			childIdentity: null,
+			childSpawnedAt: null,
+			readyAt: null,
+			stopRequestedAt: null,
+			revokeToken: null,
+			stopReason: null,
+			state: "starting",
+			startedAt: provisionalHost.claimAt ?? now,
+			lastSeenAt: now,
+			endedAt: null,
+			exitCode: null,
+			error: null,
+			cols: provisionalHost.cols ?? 120,
+			rows: provisionalHost.rows ?? 36,
+			attachedClients: 0,
+		};
+		writeHost(root, record);
+		// Mirror is best-effort; host.json is the authority for the new protocol.
+		try {
+			writeHostPid(root, provisionalHost.viewId, record.claimPid, {
+				instanceId: record.instanceId,
+				identity: record.claimIdentity,
+			});
+		} catch { /* best effort */ }
+		return { claimed: true, host: record };
+	} finally {
+		lock.lease.release();
+	}
+}
+
+/**
+ * Bounded contention retry for owner-fenced host writes (issue #70, PR #84 CI
+ * wave 2). Heartbeat/client-merge writes hold the host-meta lease for only a
+ * few milliseconds, but a one-shot acquire can land inside that window and
+ * return busy — a revoke or recovery write that silently no-ops is a real
+ * reliability bug, not just a test race. Both `busy` (live owner) and
+ * `blocked` (identity-less short hold — updateOwnedHost itself acquires
+ * host-meta without a reclaimable identity, so concurrent fenced writes look
+ * blocked to each other) are transient here: retry a few times with a short
+ * synchronous sleep before giving up. A genuinely orphaned host-meta lock
+ * (holder SIGKILLed mid-hold) survives the window and surfaces as retryable
+ * not-updated — never as ownership loss.
+ */
+const UPDATE_LOCK_BUSY_ATTEMPTS = 3;
+const UPDATE_LOCK_BUSY_SLEEP_MS = 20;
+
+/**
+ * Owner-fenced compare-and-write for host.json. Re-reads the view's record
+ * under the host-meta lease and only applies `mutate` while it still belongs
+ * to `expectedInstanceId`; a superseded instance's late heartbeat/crash/exit
+ * writes are rejected with `ownerChanged: true` and the current host (issue
+ * #70). Lease contention that survives the bounded retry returns not-updated
+ * with `ownerChanged: false` — callers treat that as retryable (heartbeats
+ * simply retry next tick; revokes/recovery re-attempt).
+ * @param {string} root
+ * @param {string} viewId
+ * @param {string} expectedInstanceId
+ * @param {(host: HostStatus) => HostStatus} mutate returns a new record
+ * @param {{ heldStartLease?: unknown, lockImpl?: typeof tryAcquireOwnedViewLock }} [opts]
+ *   heldStartLease is reserved for host-start lease nesting; lockImpl injects
+ *   the host-meta acquisition for deterministic contention tests.
+ * @returns {{ updated: boolean, ownerChanged: boolean, host: HostStatus|null }}
+ */
+export function updateOwnedHost(root, viewId, expectedInstanceId, mutate, opts = {}) {
+	const acquireHostMeta = opts.lockImpl ?? tryAcquireOwnedViewLock;
+	let lock;
+	for (let attempt = 0; ; attempt++) {
+		lock = acquireHostMeta(root, viewId, "host-meta");
+		if (lock.acquired) break;
+		// busy and blocked are both millisecond-scale holds for host-meta;
+		// neither is ownership information — only the fenced read below is.
+		if (attempt >= UPDATE_LOCK_BUSY_ATTEMPTS - 1) {
+			return { updated: false, ownerChanged: false, host: null };
+		}
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, UPDATE_LOCK_BUSY_SLEEP_MS);
+	}
+	try {
+		const host = readHost(root, viewId);
+		if (!host || !sameHostOwner(host, expectedInstanceId)) {
+			return { updated: false, ownerChanged: true, host };
+		}
+		const next = mutate(host);
+		// The mutate result must still belong to the expected instance: a buggy or
+		// hijacked callback that swaps the owner token is never written (issue #70).
+		if (!sameHostOwner(next, expectedInstanceId)) {
+			return { updated: false, ownerChanged: true, host };
+		}
+		writeHost(root, next);
+		try {
+			writeHostPid(root, viewId, next.runnerPid ?? null, {
+				instanceId: next.instanceId,
+				identity: next.runnerIdentity ?? null,
+			});
+		} catch { /* best effort */ }
+		return { updated: true, ownerChanged: false, host: next };
+	} finally {
+		lock.lease.release();
+	}
 }
 
 /** @param {string} root @param {string} viewId @returns {number|null} */
@@ -177,6 +329,8 @@ function mtime(dir) {
  * @property {ViewState|null} state
  * @property {boolean} alive  Whether the row's current run pid/foreground activity is alive.
  * @property {boolean} hostAlive Whether a PTY host/socket is alive and attachable.
+ * @property {boolean} hostActive Whether an unreplaced host claim exists (starting/alive/stopping).
+ * @property {boolean} hostReady Whether the host claims readiness (alive + readyAt); metadata hint only.
  * @property {HostStatus|null} host
  * @property {import("./types.mjs").ReviewSummary} [review]
  * @property {import("./types.mjs").DiagnosticSummary} [diagnostics]
@@ -202,9 +356,14 @@ export function loadRow(root, viewId) {
 	// poll, but foreground extension events mirror processState into state.json.
 	if (!alive && enrichedState?.processState === "alive") alive = true;
 	const host = readHost(root, viewId);
-	const hostPid = host?.runnerPid ?? readHostPid(root, viewId);
+	// New-protocol records carry an explicit runnerPid (null until spawn
+	// confirms); only legacy records without the property fall back to the
+	// host-pid mirror (issue #70).
+	const hostPid = host && Object.hasOwn(host, "runnerPid") ? host.runnerPid : readHostPid(root, viewId);
 	const hostAlive = Boolean(host && (host.state === "alive" || host.state === "starting") && isAlive(hostPid));
-	return { meta, state: enrichedState, alive, hostAlive, host, ...summaries };
+	const hostActive = Boolean(host && (host.state === "starting" || host.state === "alive" || host.state === "stopping"));
+	const hostReady = Boolean(hostActive && host.state === "alive" && host.readyAt != null);
+	return { meta, state: enrichedState, alive, hostAlive, hostActive, hostReady, host, ...summaries };
 }
 
 /** @param {string} root @param {string} viewId */

package/src/core/types.mjs

@@ -6,7 +6,7 @@
 /** Semantic (task) state of a row. @typedef {"queued"|"working"|"needs_input"|"idle"|"completed"|"failed"|"stopped"} SemanticState */
 /** Process/liveness state. @typedef {"alive"|"exited"} ProcessState */
 /** PTY host mode. @typedef {"json-runner"|"pty"} HostMode */
-/** PTY host liveness. @typedef {"starting"|"alive"|"exited"|"failed"} HostState */
+/** PTY host liveness. @typedef {"starting"|"alive"|"stopping"|"exited"|"failed"} HostState */
 /** How a run was kicked off. @typedef {"dispatch"|"reply"|"plan"|"plan_change"|"plan_approval"} RunKind */
 /** Worktree isolation mode for a row. @typedef {"off"|"worktree"} WorktreeMode */
 /** Diagnostic severity. @typedef {"info"|"warn"|"error"} DiagnosticLevel */
@@ -141,6 +141,19 @@ export const GROUP_LABELS = {
  * @property {number} rows
  * @property {number} attachedClients
  * @property {boolean} [attachedEver] Whether any client attached to this host.
+ * @property {string|null} [instanceId] Owner/fencing token for this host launch (issue #70).
+ * @property {string|null} [configPath] Per-instance config file this host was launched with.
+ * @property {number|null} [claimAt] When the provisional claim was written (epoch ms).
+ * @property {number|null} [claimPid] PID of the service process that wrote the claim.
+ * @property {{pid:number,startToken:string|null}|null} [claimIdentity] Launch-time identity of the claiming service process.
+ * @property {{pid:number,startToken:string|null}|null} [runnerIdentity] Stable identity of the runner process.
+ * @property {number|null} [runnerSpawnedAt] When the runner spawn was confirmed (null = not yet spawned).
+ * @property {{pid:number,startToken:string|null}|null} [childIdentity] Stable identity of the child Pi process.
+ * @property {number|null} [childSpawnedAt] When the child spawn was confirmed (null = not yet spawned).
+ * @property {number|null} [readyAt] Set only after endpoint bind + child creation; alive implies readyAt != null.
+ * @property {number|null} [stopRequestedAt] When a revoke was requested via the host record.
+ * @property {string|null} [revokeToken] Random token written by requestHostStop to fence duplicate revokes.
+ * @property {string|null} [stopReason] Human-readable reason recorded with the revoke.
  */
 
 /**
@@ -213,6 +226,9 @@ export const GROUP_LABELS = {
  * @property {number} cols
  * @property {number} rows
  * @property {number|null} screenLogMaxBytes per-view screen.log write cap; null = runner default
+ * @property {string|null} [instanceId] Owner/fencing token for this host launch (issue #70).
+ * @property {string|null} [configPath] Per-instance config file path; each launch owns its own so concurrent launches never share a config.
+ * @property {string|null} [socketPath] Per-instance control endpoint the spawned runner must bind.
  */
 
 /**

package/src/core/warm-host-sweeper.mjs

@@ -0,0 +1,150 @@
+/**
+ * Warm-host sweep reclaim (issue #75).
+ *
+ * Idle PTY hosts must not live forever: after detach the runner is a detached
+ * orphan that nothing else will reap (Windows has no parent-death cascade, and
+ * the dashboard host may exit without a cleanup hook). The design intent
+ * (AGENT_BOARD_WARM_HOST_TTL_MS / MAX_WARM_HOSTS) already exists in
+ * service.mjs pruneWarmHosts but only fires lazily on attach/prewarm/dispatch.
+ * This module extracts the pure eviction decision plus a periodic sweeper so
+ * the TTL actually runs.
+ */
+
+/** @param {import("./store.mjs").Row} row */
+export function hasPendingQuestions(row) {
+	return Array.isArray(row.state?.pendingQuestions) && row.state.pendingQuestions.length > 0;
+}
+
+/**
+ * Busy = an agent run is active (queued/working) or the session is waiting on
+ * user questions. Idle/completed/failed/stopped are never busy.
+ * @param {import("./store.mjs").Row} row
+ */
+export function isAgentBusy(row) {
+	const st = row.state?.semanticState;
+	return Boolean(row.alive && (st === "queued" || st === "working" || hasPendingQuestions(row)));
+}
+
+/**
+ * Pure eviction decision for warm PTY hosts. No IO, no env: every threshold is
+ * passed in so the logic is directly unit-testable.
+ *
+ * idle = host alive && !busy && no attached clients && not keepViewId.
+ * graceMs exempts freshly started hosts (attach handoff race: ensureHost has
+ * started a host but the client has not connected yet).
+ * TTL eviction runs first; survivors over maxWarm are evicted oldest-first by
+ * idleSince = max(state.lastActivityAt, host.startedAt) || meta.updatedAt (host-level
+ * idle counts from host start, so a stale lastActivityAt from a previous host
+ * incarnation never makes a fresh host look idle longer than it has been up).
+ *
+ * @param {Array<import("./store.mjs").Row>} rows
+ * @param {{ now: number, maxWarm: number, ttlMs: number, graceMs?: number, keepViewId?: string|null }} o
+ * @returns {{ ttlEvicted: string[], excessEvicted: string[] }} viewIds, ttl group first
+ */
+export function selectIdleHostsToEvict(rows, { now, maxWarm, ttlMs, graceMs = 0, keepViewId = null }) {
+	// Both-zero = eviction disabled entirely. Callers (service.pruneWarmHosts)
+	// may additionally early-return for the same reason.
+	if (maxWarm === 0 && ttlMs === 0) return { ttlEvicted: [], excessEvicted: [] };
+	const idle = [];
+	for (const row of rows) {
+		if (keepViewId != null && row.meta.id === keepViewId) continue;
+		if (!row.hostAlive) continue;
+		if (isAgentBusy(row)) continue;
+		if ((row.host?.attachedClients ?? 0) !== 0) continue;
+		const startedAt = row.host?.startedAt;
+		if (graceMs > 0 && startedAt != null && now - startedAt < graceMs) continue;
+		// Host-level idle counts from host start: a stale lastActivityAt from a
+		// previous host incarnation must not make a freshly prewarmed host look
+		// idle for longer than it has actually been up (issue #75 review #1).
+		const idleSince = Math.max(row.state?.lastActivityAt ?? 0, startedAt ?? 0) || row.meta.updatedAt;
+		idle.push({ id: row.meta.id, idleSince });
+	}
+	const ttlEvicted = [];
+	const survivors = [];
+	for (const it of idle) {
+		// Keep the historical semantics: ttlMs === 0 disables the ttl branch
+		// (only the maxWarm cap applies); both zero disables eviction entirely.
+		if (ttlMs > 0 && now - it.idleSince > ttlMs) ttlEvicted.push(it.id);
+		else survivors.push(it);
+	}
+	survivors.sort((a, b) => a.idleSince - b.idleSince);
+	const excess = Math.max(0, survivors.length - maxWarm);
+	return { ttlEvicted, excessEvicted: survivors.slice(0, excess).map((it) => it.id) };
+}
+
+/**
+ * Periodic sweeper for warm hosts. The interval timer is unref'd so it never
+ * holds the host pi's event loop open on exit. intervalMs <= 0 disables the
+ * periodic part; sweepNow() always works.
+ *
+ * stop() only stops the periodic timer: sweepNow() stays available afterwards
+ * (the lifecycle wiring calls sweepNow() again on shutdown/dispose). start()
+ * is idempotent and may restart the timer after a stop.
+ * @param {{ sweep: () => void, intervalMs: number }} o
+ */
+export function createWarmHostSweeper({ sweep, intervalMs }) {
+	let timer = null;
+	return {
+		active: true,
+		start() {
+			if (timer !== null) return;
+			if (intervalMs > 0) {
+				timer = setInterval(() => {
+					try { sweep(); } catch { /* best-effort */ }
+				}, intervalMs);
+				if (typeof timer.unref === "function") timer.unref();
+			}
+		},
+		sweepNow() {
+			try { sweep(); } catch { /* best-effort */ }
+		},
+		stop() {
+			if (timer !== null) {
+				clearInterval(timer);
+				timer = null;
+			}
+		},
+	};
+}
+
+/**
+ * Wire the sweeper to a host pi extension lifetime: sweep once on attach
+ * (reclaims hosts leaked by a previous host that died without cleanup), run
+ * periodically, and sweep again on session_shutdown (host pi exiting or the
+ * extension instance being reloaded for a session switch).
+ *
+ * Child pi processes (AGENT_BOARD_CHILD=1 / AGENT_VIEW_CHILD=1) must never
+ * sweep: they share the same board root and would terminate their own runner
+ * (suicide chain). They get a strict no-op.
+ *
+ * @param {{ on?: (event: any, fn: () => void) => any }} pi — any, not a narrower
+ *   string-keyed signature: pi's ExtensionAPI.on is a union of literal event-name
+ *   overloads and would otherwise fail structural assignment from TypeScript
+ *   callers (contravariant parameter check).
+ * @param {{ isHostedChild: boolean, sweep: () => void, intervalMs: number }} o
+ */
+export function attachWarmHostSweeper(pi, { isHostedChild, sweep, intervalMs }) {
+	// Child pi processes and board-spawned non-host workers must never sweep:
+	// children would terminate their own runner (suicide chain); workers
+	// (job/state runners set AGENT_BOARD_NO_SWEEP=1) would churn the shared root.
+	if (isHostedChild || process.env.AGENT_BOARD_NO_SWEEP === "1") {
+		return { active: false, dispose() {} };
+	}
+	const sweeper = createWarmHostSweeper({ sweep, intervalMs });
+	let shutdown = false;
+	const onShutdown = () => {
+		if (shutdown) return;
+		shutdown = true;
+		sweeper.sweepNow();
+		sweeper.stop();
+	};
+	pi.on?.("session_shutdown", onShutdown);
+	sweeper.start();
+	sweeper.sweepNow(); // 回收上一个宿主（可能非正常退出）遗留的 warm hosts
+	return {
+		active: true,
+		dispose() {
+			onShutdown();
+		},
+	};
+}

package/src/index.ts

@@ -11,7 +11,8 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { resolvePiInvocation } from "./core/invocation.mjs";
 import { controlSocketPathFor, defaultRoot } from "./core/paths.mjs";
 import { listRows } from "./core/store.mjs";
-import { createService } from "./runtime/service.mjs";
+import { createService, envInt } from "./runtime/service.mjs";
+import { attachWarmHostSweeper } from "./core/warm-host-sweeper.mjs";
 import { openDashboard, registerAgentBoardCommand } from "./commands/agent-board.js";
 import { registerBgCommand } from "./commands/bg.js";
 
@@ -39,6 +40,33 @@ export default function piAgentBoard(pi: ExtensionAPI): void {
 		piArgsPrefix,
 		getThinkingLevel: () => pi.getThinkingLevel(),
 	};
+
+	// Warm-host reclaim (issue #75): idle PTY hosts must not leak forever after
+	// detach. Sweep once now (reclaims hosts orphaned by a previous host pi that
+	// exited without cleanup), then periodically; sweep again on shutdown.
+	// Child pi processes skip entirely (they share the board root and would
+	// terminate their own runner). serviceForContext is defined before the attach
+	// call because the sweeper sweeps synchronously on attach and the sweep
+	// closure references it (no TDZ).
+	const serviceForContext = () =>
+		createService({ root, runnerScript: RUNNER_SCRIPT, ptyRunnerScript: PTY_RUNNER_SCRIPT, titleRunnerScript: TITLE_RUNNER_SCRIPT, autoStateRunnerScript: AUTO_STATE_RUNNER_SCRIPT, piCommand, piArgsPrefix, defaultCwd: process.cwd() });
+	let sweepService: ReturnType<typeof createService> | null = null;
+	attachWarmHostSweeper(pi, {
+		isHostedChild,
+		sweep: () => {
+			try {
+				// Reuse one service instance per extension lifetime: createService
+				// schedules a screen-log GC on construction, so per-tick creation
+				// would turn an event-driven cost into a timed one.
+				sweepService ??= serviceForContext();
+				sweepService.pruneWarmHosts();
+			} catch {
+				/* best-effort: never break the session over a sweep */
+			}
+		},
+		intervalMs: envInt("AGENT_BOARD_SWEEP_INTERVAL_MS", 60_000, 0, 24 * 60 * 60 * 1000, "AGENT_VIEW_SWEEP_INTERVAL_MS"),
+	});
+
 	registerAgentBoardCommand(pi, commandOpts);
 	registerBgCommand(pi, commandOpts);
 	pi.registerFlag("agent-board", {
@@ -48,8 +76,17 @@ export default function piAgentBoard(pi: ExtensionAPI): void {
 	});
 
 	// Footer status: reconcile stale rows and surface how many need attention.
+	// Live model list for the stale-defaultModel launch guard (issue #90); the
+	// service calls it per validation, and undefined conservatively skips.
+	const availableModelsFor = (ctx: ExtensionContext) => () => {
+		try {
+			return ctx.modelRegistry.getAvailable();
+		} catch {
+			return undefined;
+		}
+	};
 	const serviceFor = (ctx: ExtensionContext) =>
-		createService({ root, runnerScript: RUNNER_SCRIPT, ptyRunnerScript: PTY_RUNNER_SCRIPT, titleRunnerScript: TITLE_RUNNER_SCRIPT, autoStateRunnerScript: AUTO_STATE_RUNNER_SCRIPT, piCommand, piArgsPrefix, defaultCwd: ctx.cwd });
+		createService({ root, runnerScript: RUNNER_SCRIPT, ptyRunnerScript: PTY_RUNNER_SCRIPT, titleRunnerScript: TITLE_RUNNER_SCRIPT, autoStateRunnerScript: AUTO_STATE_RUNNER_SCRIPT, piCommand, piArgsPrefix, defaultCwd: ctx.cwd, availableModels: availableModelsFor(ctx) });
 
 	const updateStatus = (ctx: ExtensionContext) => {
 		try {
@@ -84,7 +121,7 @@ export default function piAgentBoard(pi: ExtensionAPI): void {
 		}
 		updateStatus(ctx);
 		if (event.reason === "startup" && !isHostedChild && pi.getFlag("agent-board") === true && ctx.hasUI) {
-			const service = createService({ root, runnerScript: RUNNER_SCRIPT, ptyRunnerScript: PTY_RUNNER_SCRIPT, titleRunnerScript: TITLE_RUNNER_SCRIPT, autoStateRunnerScript: AUTO_STATE_RUNNER_SCRIPT, piCommand, piArgsPrefix, defaultCwd: ctx.cwd });
+			const service = createService({ root, runnerScript: RUNNER_SCRIPT, ptyRunnerScript: PTY_RUNNER_SCRIPT, titleRunnerScript: TITLE_RUNNER_SCRIPT, autoStateRunnerScript: AUTO_STATE_RUNNER_SCRIPT, piCommand, piArgsPrefix, defaultCwd: ctx.cwd, availableModels: availableModelsFor(ctx) });
 			service.reconcile();
 			ctx.ui.setWorkingVisible(false);
 			ctx.ui.setHeader(() => ({ render: () => [], invalidate() {} }));