@danypops/pi-jittor 0.4.0 → 0.5.1

package/extension/src/index.ts

@@ -34,7 +34,8 @@ import {
 	validateTaskFocusEvent,
 } from "@danypops/jittor";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { showCacheEconomicsPanel } from "./observability/cache-economics-view.ts";
+import { jittorArgumentCompletions, jittorUsageError } from "./jittor-command.ts";
+import { showJittorShell } from "./jittor-shell.ts";
 import {
 	basePromptSegment,
 	buildBasePromptItems,
@@ -51,14 +52,12 @@ import { type CompactionProgress, type IntegratedFooterState, installIntegratedF
 import { LocalRunTelemetry } from "./observability/model-run.ts";
 import { captureProviderContextSnapshot } from "./observability/provider-context-snapshot.ts";
 import { ProviderResponseTelemetry } from "./observability/provider-response.ts";
-import { buildFooterBudget, providerBudgetMetricQuery, showJittorPanel } from "./observability/status.ts";
+import { buildFooterBudget, providerBudgetMetricQuery } from "./observability/status.ts";
 import { showUsagePanel } from "./observability/usage.ts";
-import { showBenchmarkPanel } from "./optimization/model-selection-panel.ts";
 import { CodexRecoveryCapability, type CodexRecoveryRuntime, SYSTEM_RECOVERY_RUNTIME } from "./optimization/recovery/codex.ts";
 import { callJittor } from "./service-client.ts";
 import { cacheSessionSecret, forgetSessionSecret, sessionSecretField } from "./session-identity.ts";
 import { type CodexRecoveryControl, type EnforcementControl, persistentEnforcementControl, type UsageBudgetControl } from "./settings.ts";
-import { showSettingsPanel } from "./settings-tui.ts";
 
 export { formatFooterStatus } from "./observability/status.ts";
 export type { CodexRecoveryRuntime } from "./optimization/recovery/codex.ts";
@@ -574,21 +573,53 @@ export function registerJittorExtension(
 
 	pi.registerCommand("jittor", {
 		description: "Jittor settings, routing status, benchmarks, cache economics, and Codex recovery controls",
+		getArgumentCompletions: jittorArgumentCompletions,
 		handler: async (args, ctx) => {
 			const action = args.trim().toLowerCase();
-			if (action === "" || action === "settings") {
-				await showSettingsPanel(ctx, enforcement, codexRecovery, usageBudgets, {
-					setEnforcement: async (enabled) => (enabled ? enable(ctx) : disable(ctx)),
-					setFooter: async (enabled) => {
-						await enforcement.setFooterEnabled(enabled);
-						showFooter(ctx);
-						if (enabled) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
-					},
-					setRecovery: async (enabled) => {
-						if (!enabled) cancelRecovery(true);
-						await codexRecovery.setCodexRecoveryEnabled(enabled);
+			const usageError = jittorUsageError(action);
+			if (usageError) {
+				ctx.ui.notify(usageError, "warning");
+				return;
+			}
+			// One shared JittorShellDeps builder for every /jittor entry point below -- all four tabs
+			// (Settings/Status/Benchmarks/Cache) are reachable from a single opened shell regardless of
+			// which subcommand opened it, so every entry point needs the full dependency set, not just
+			// its own tab's. `benchmarksTask` overrides the domain/type only for an explicit
+			// "/jittor benchmarks ..." invocation; every other entry point defaults to general/general
+			// (only meaningfully exercised if the user tab-cycles into Benchmarks from elsewhere).
+			const buildShellDeps = (benchmarksTask?: {
+				domain: ModelTaskDomain;
+				type: ModelTaskType;
+			}): Parameters<typeof showJittorShell>[1] => ({
+				settings: {
+					enforcement,
+					recovery: codexRecovery,
+					budgets: usageBudgets,
+					effects: {
+						setEnforcement: async (enabled) => (enabled ? enable(ctx) : disable(ctx)),
+						setFooter: async (enabled) => {
+							await enforcement.setFooterEnabled(enabled);
+							showFooter(ctx);
+							if (enabled) await refreshFooter(client, footerState, ctx.sessionManager.getSessionId()).catch(() => undefined);
+						},
+						setRecovery: async (enabled) => {
+							if (!enabled) cancelRecovery(true);
+							await codexRecovery.setCodexRecoveryEnabled(enabled);
+						},
 					},
-				});
+				},
+				status: { client },
+				benchmarks: {
+					client,
+					candidates: benchmarkCandidatesFromPi(scopedOrAvailableModels(ctx), pi.getThinkingLevel()),
+					currentIdentity: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "",
+					domain: benchmarksTask?.domain ?? "general",
+					type: benchmarksTask?.type ?? "general",
+				},
+				cache: { client, windowMs: 7 * MILLISECONDS_PER_DAY },
+			});
+			if (action === "" || action === "settings") {
+				await showJittorShell(ctx, buildShellDeps(), "settings");
 				return;
 			}
 			if (action === "benchmarks" || action.startsWith("benchmarks ")) {
@@ -613,19 +644,15 @@ export function registerJittorExtension(
 					ctx.ui.notify("Usage: /jittor benchmarks [coding|general] [research|planning|general]", "warning");
 					return;
 				}
-				const candidates = benchmarkCandidatesFromPi(scopedOrAvailableModels(ctx), pi.getThinkingLevel());
-				await showBenchmarkPanel(
+				await showJittorShell(
 					ctx,
-					client,
-					candidates,
-					`${ctx.model.provider}/${ctx.model.id}`,
-					requestedDomain ?? "general",
-					requestedType ?? "general",
+					buildShellDeps({ domain: requestedDomain ?? "general", type: requestedType ?? "general" }),
+					"benchmarks",
 				);
 				return;
 			}
 			if (action === "cache") {
-				await showCacheEconomicsPanel(ctx, client, 7 * MILLISECONDS_PER_DAY);
+				await showJittorShell(ctx, buildShellDeps(), "cache");
 				return;
 			}
 			if (action === "outcome accepted" || action === "outcome rejected") {
@@ -701,13 +728,13 @@ export function registerJittorExtension(
 				);
 				return;
 			}
-			// Reached only for the explicit "status" keyword or any other unrecognized text; bare "" is
-			// handled above by the settings branch, so this always has a non-empty, non-settings action.
+			// Reached only for the explicit "status" keyword -- jittorUsageError above already rejected
+			// anything else this handler doesn't recognize, so this is never an unrecognized fallback.
 			if (!enforcement.isEnabled()) {
 				ctx.ui.notify("Jittor is monitor-only. Run /jittor on to re-enable blocking.", "info");
 				return;
 			}
-			await showJittorPanel(ctx, client);
+			await showJittorShell(ctx, buildShellDeps(), "status");
 		},
 	});
 

package/extension/src/jittor-command.ts

@@ -0,0 +1,110 @@
+/**
+ * The full argument grammar for /jittor, as one small data table -- the single source of truth
+ * both jittorUsageError (validation) and jittorArgumentCompletions (tab-completion) read from, so
+ * the two can never drift apart (a phrase added to one is automatically valid/completable in the
+ * other). /jittor's own registerCommand handler in index.ts owns dispatching a validated phrase to
+ * its real behavior; this module only ever answers "is this a real phrase" and "what could this
+ * become".
+ *
+ * `benchmarks` is deliberately excluded from LEAF_PHRASES: its own domain/type combinatorics
+ * (TASK_DOMAINS x TASK_TYPES, either order) already have a dedicated, tested malformed-usage
+ * branch in index.ts with its own specific error message -- this module defers to it entirely
+ * for validation, and only mirrors its real phrase space for completions.
+ */
+import { TASK_DOMAINS, TASK_TYPES } from "@danypops/jittor";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+export const JITTOR_TOP_LEVEL_COMMANDS = [
+	"settings",
+	"status",
+	"benchmarks",
+	"cache",
+	"outcome",
+	"recovery",
+	"on",
+	"off",
+	"footer",
+	"context",
+] as const;
+
+/** Every real, currently-supported phrase EXCEPT benchmarks (see module doc comment). */
+const LEAF_PHRASES = [
+	"",
+	"settings",
+	"status",
+	"cache",
+	"context",
+	"on",
+	"enable",
+	"off",
+	"disable",
+	"outcome accepted",
+	"outcome rejected",
+	"recovery",
+	"recovery status",
+	"recovery on",
+	"recovery enable",
+	"recovery off",
+	"recovery disable",
+	"recovery cancel",
+	"footer on",
+	"footer enable",
+	"footer off",
+	"footer disable",
+] as const;
+
+/** Real benchmarks phrases: bare, one axis alone, or both axes in either accepted word order -- mirrors index.ts's own lenient two-word-any-order parsing, for completions only. */
+function benchmarksPhrases(): string[] {
+	const phrases: string[] = ["benchmarks"];
+	for (const domain of TASK_DOMAINS) phrases.push(`benchmarks ${domain}`);
+	for (const type of TASK_TYPES) phrases.push(`benchmarks ${type}`);
+	for (const domain of TASK_DOMAINS) {
+		for (const type of TASK_TYPES) {
+			phrases.push(`benchmarks ${domain} ${type}`, `benchmarks ${type} ${domain}`);
+		}
+	}
+	return phrases;
+}
+
+/**
+ * null when `action` (already trimmed/lowercased by the caller, matching index.ts's own
+ * convention) is a real, currently-supported phrase; otherwise a human-readable message naming
+ * exactly what was wrong and what the real alternatives are -- never a silent fallback to
+ * unrelated behavior (the bug class this replaces: an unrecognized word, or a valid command with
+ * an unrecognized trailing argument, used to silently open the status panel instead).
+ */
+export function jittorUsageError(action: string): string | null {
+	if ((LEAF_PHRASES as readonly string[]).includes(action)) return null;
+	if (action === "benchmarks" || action.startsWith("benchmarks ")) return null;
+
+	const words = action.split(/\s+/).filter(Boolean);
+	const firstWord = words[0]!;
+	if (!(JITTOR_TOP_LEVEL_COMMANDS as readonly string[]).includes(firstWord)) {
+		return `Unknown /jittor command "${firstWord}". Allowed: ${JITTOR_TOP_LEVEL_COMMANDS.join(", ")}.`;
+	}
+	const subPhrases = LEAF_PHRASES.filter((phrase) => phrase.startsWith(`${firstWord} `));
+	if (subPhrases.length === 0) return `/jittor ${firstWord} does not take any arguments.`;
+	const subArguments = subPhrases.map((phrase) => phrase.slice(firstWord.length + 1));
+	return `Unknown /jittor ${firstWord} argument "${words.slice(1).join(" ")}". Allowed: ${subArguments.join(", ")}.`;
+}
+
+let cachedCompletionPhrases: string[] | undefined;
+function completionPhrases(): string[] {
+	if (!cachedCompletionPhrases) cachedCompletionPhrases = [...LEAF_PHRASES.filter((phrase) => phrase.length > 0), ...benchmarksPhrases()];
+	return cachedCompletionPhrases;
+}
+
+/**
+ * Every real phrase (see completionPhrases) that could still result from typing more after
+ * `argumentPrefix`, matching pi-tui's own SlashCommand.getArgumentCompletions contract: `value` is
+ * the FULL replacement for the entire argument text typed so far (pi-tui's own applyCompletion
+ * replaces the whole prefix span with it, not just the trailing word), so every candidate here is a
+ * complete phrase, not a per-word delta. Matching is case-insensitive on the typed prefix (a human
+ * may capitalize while typing); returned values are always canonical lowercase.
+ */
+export function jittorArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
+	const needle = argumentPrefix.toLowerCase();
+	const matches = completionPhrases().filter((phrase) => phrase.startsWith(needle));
+	if (matches.length === 0) return null;
+	return matches.map((value) => ({ value, label: value }));
+}

package/extension/src/jittor-shell.ts

@@ -0,0 +1,339 @@
+/**
+ * Consolidates /jittor's four independent overlays (Settings, Status, Benchmarks, Cache) into one
+ * Envelope-equivalent shell: a single outer BorderedSelectPanel owns the one shared border/title,
+ * a TabbedContainer inside it owns the persistent tab bar and hands render/input straight to
+ * whichever tab is active -- the composable primitive that replaces the old ad hoc
+ * close-one-overlay-open-a-different-one pattern (see malevich-tui-components' own
+ * TabbedContainer doc comment). Modeled on DanyPops/vehicle's own /safety command
+ * (vehicle-safety-command.ts), the real precedent for Envelope/TabbedContainer composition in
+ * this ecosystem.
+ *
+ * Each tab's real interactive content and side-effect handling stays owned by its existing
+ * module (settings-tui.ts, observability/status.ts, optimization/model-selection-panel.ts,
+ * observability/cache-economics-view.ts) via their exported `create*Panel`/`run*Action`/`fetch*`
+ * functions -- this module only composes them, so the standalone single-panel entry points and
+ * the unified shell can never drift apart on what a keypress actually does.
+ *
+ * Per-tab data is fetched lazily: only the initially requested tab (plus Settings, which reads
+ * already-in-memory persisted state and costs no daemon round trip at all) is fetched before the
+ * shell first opens. Switching to a tab that has never been visited fetches it once, on first
+ * visit, not before.
+ */
+import type { ModelCandidate, ModelRankingResult, ModelTaskDomain, ModelTaskType, RouterStatus } from "@danypops/jittor";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { BorderedSelectPanel, type MnemonicContext, type TabBarTheme, TabbedContainer, type TextMeasure } from "malevich-tui-components";
+import {
+	type CacheEconomicsPanelAction,
+	type CacheEconomicsPanelClient,
+	createCacheEconomicsPanel,
+	fetchCacheEconomicsSummary,
+	showCacheEconomicsPanel,
+} from "./observability/cache-economics-view.ts";
+import {
+	createStatusPanel,
+	fetchStatusSnapshot,
+	type JittorPanelClient,
+	type PanelAction,
+	runStatusAction,
+	type StatusPanelSnapshot,
+	showJittorPanel,
+} from "./observability/status.ts";
+import {
+	type BenchmarkPanelAction,
+	type BenchmarkPanelClient,
+	createBenchmarkPanel,
+	fetchBenchmarkRanking,
+	showBenchmarkPanel,
+} from "./optimization/model-selection-panel.ts";
+import type { CodexRecoveryControl, EnforcementControl, UsageBudgetControl } from "./settings.ts";
+import {
+	createSettingsPanel,
+	runSettingsAction,
+	type SettingsAction,
+	type SettingsEffects,
+	type SettingsSnapshot,
+	settingsSnapshot,
+	showSettingsPanel,
+} from "./settings-tui.ts";
+
+export type JittorTabKey = "settings" | "status" | "benchmarks" | "cache";
+
+export interface JittorShellDeps {
+	settings: {
+		enforcement: EnforcementControl;
+		recovery: CodexRecoveryControl;
+		budgets: UsageBudgetControl;
+		effects: SettingsEffects;
+	};
+	status: { client: JittorPanelClient };
+	benchmarks: {
+		client: BenchmarkPanelClient;
+		candidates: ModelCandidate[];
+		currentIdentity: string;
+		domain: ModelTaskDomain;
+		type: ModelTaskType;
+	};
+	cache: { client: CacheEconomicsPanelClient; windowMs: number; now?: () => number };
+}
+
+interface ShellTheme {
+	fg(color: string, text: string): string;
+	bold(text: string): string;
+}
+
+const hostTextMeasure: TextMeasure = { visibleWidth, truncateToWidth };
+
+/**
+ * A real tree describing every key genuinely reachable at once inside the shell -- the shell's
+ * own tab-cycling/close bindings at the root, plus each tab's own bindings as a sibling leaf
+ * (siblings are never simultaneously active, so two tabs may freely reuse the same letter for
+ * different things; only a leaf's own root-to-tab path is checked). Kept in sync by hand with
+ * what createStatusPanel/createBenchmarkPanel/createCacheEconomicsPanel/createSettingsPanel and
+ * this module's own outer handleInput actually wire -- run through assertNoMnemonicConflicts as a
+ * standing test so a newly added keybinding that collides fails loudly, not just live.
+ */
+export function jittorShellMnemonicTree(): MnemonicContext {
+	return {
+		name: "jittor-shell",
+		bindings: [
+			{ key: "escape", description: "close shell" },
+			{ key: "ctrl+c", description: "close shell" },
+			{ key: "tab", description: "next tab" },
+			{ key: "shift+tab", description: "previous tab" },
+			{ key: "left", description: "previous tab" },
+			{ key: "right", description: "next tab" },
+		],
+		children: [
+			{
+				name: "settings",
+				bindings: [
+					{ key: "up", description: "menu up" },
+					{ key: "down", description: "menu down" },
+					{ key: "enter", description: "menu activate" },
+					{ key: "space", description: "menu activate" },
+					{ key: "escape", description: "close shell" },
+				],
+			},
+			{
+				name: "status",
+				bindings: [
+					{ key: "r", description: "refresh status" },
+					{ key: "p", description: "pause/resume" },
+					{ key: "o", description: "override route" },
+					{ key: "c", description: "clear override" },
+					{ key: "escape", description: "close shell" },
+				],
+			},
+			{
+				name: "benchmarks",
+				bindings: [
+					{ key: "r", description: "refresh benchmarks" },
+					{ key: "escape", description: "close shell" },
+				],
+			},
+			{
+				name: "cache",
+				bindings: [
+					{ key: "r", description: "refresh cache" },
+					{ key: "escape", description: "close shell" },
+				],
+			},
+		],
+	};
+}
+
+interface ShellState {
+	settings?: SettingsSnapshot;
+	status?: StatusPanelSnapshot;
+	benchmarks?: ModelRankingResult;
+	cache?: Awaited<ReturnType<typeof fetchCacheEconomicsSummary>>;
+}
+
+async function ensureLoaded(
+	activeKey: JittorTabKey,
+	state: ShellState,
+	deps: JittorShellDeps,
+	ctx: ExtensionCommandContext,
+): Promise<void> {
+	// Settings reads already-in-memory persisted state -- no daemon round trip, so eagerly keeping
+	// it fresh costs nothing and never violates "no network call for a tab never visited".
+	state.settings = settingsSnapshot(deps.settings.enforcement, deps.settings.recovery, deps.settings.budgets);
+	if (activeKey === "status" && state.status === undefined) {
+		state.status = await fetchStatusSnapshot(deps.status.client, ctx.sessionManager.getSessionId());
+	}
+	if (activeKey === "benchmarks" && state.benchmarks === undefined) {
+		state.benchmarks = await fetchBenchmarkRanking(
+			ctx,
+			deps.benchmarks.client,
+			deps.benchmarks.candidates,
+			deps.benchmarks.domain,
+			deps.benchmarks.type,
+		);
+	}
+	if (activeKey === "cache" && state.cache === undefined) {
+		state.cache = await fetchCacheEconomicsSummary(deps.cache.client, deps.cache.windowMs, deps.cache.now);
+	}
+}
+
+function loadingContent(label: string) {
+	return {
+		invalidate: () => {},
+		render: (width: number): string[] => [truncateToWidth(`Loading ${label}\u2026`, width, "\u2026")],
+	};
+}
+
+type ShellOutcome =
+	| { kind: "close" }
+	| { kind: "tab-changed" }
+	| { kind: "settings"; action: SettingsAction }
+	| { kind: "status"; action: PanelAction }
+	| { kind: "benchmarks"; action: BenchmarkPanelAction }
+	| { kind: "cache"; action: CacheEconomicsPanelAction };
+
+function tabBarTheme(theme: ShellTheme): TabBarTheme {
+	return {
+		tab: (text) => theme.fg("dim", text),
+		activeTab: (text) => theme.bold(theme.fg("accent", text)),
+		mnemonic: (text) => theme.bold(text),
+	};
+}
+
+/**
+ * Falls back to each subcommand's own already-tested non-TUI notify (outside TUI mode, there is
+ * no tab bar to consolidate -- one plain-text notify per subcommand is unchanged and correct).
+ */
+async function showNonTuiFallback(ctx: ExtensionCommandContext, deps: JittorShellDeps, initialTab: JittorTabKey): Promise<void> {
+	if (initialTab === "settings")
+		return showSettingsPanel(ctx, deps.settings.enforcement, deps.settings.recovery, deps.settings.budgets, deps.settings.effects);
+	if (initialTab === "status") return showJittorPanel(ctx, deps.status.client);
+	if (initialTab === "benchmarks")
+		return showBenchmarkPanel(
+			ctx,
+			deps.benchmarks.client,
+			deps.benchmarks.candidates,
+			deps.benchmarks.currentIdentity,
+			deps.benchmarks.domain,
+			deps.benchmarks.type,
+		);
+	return showCacheEconomicsPanel(ctx, deps.cache.client, deps.cache.windowMs, deps.cache.now);
+}
+
+export async function showJittorShell(
+	ctx: ExtensionCommandContext,
+	deps: JittorShellDeps,
+	initialTab: JittorTabKey = "settings",
+): Promise<void> {
+	if (ctx.mode !== "tui") return showNonTuiFallback(ctx, deps, initialTab);
+
+	let activeKey: JittorTabKey = initialTab;
+	const state: ShellState = {};
+
+	for (;;) {
+		await ensureLoaded(activeKey, state, deps, ctx);
+		const outcome = await ctx.ui.custom<ShellOutcome>((tui, theme, _keybindings, done) => {
+			const tabs = [
+				{
+					key: "settings" as const,
+					label: "Settings",
+					content: createSettingsPanel(state.settings!, theme, (action) => done({ kind: "settings", action }), 0, false),
+				},
+				{
+					key: "status" as const,
+					label: "Status",
+					mnemonic: "u",
+					content:
+						state.status === undefined
+							? loadingContent("Status")
+							: createStatusPanel(state.status, theme, (action) => done({ kind: "status", action }), false),
+				},
+				{
+					key: "benchmarks" as const,
+					label: "Benchmarks",
+					content:
+						state.benchmarks === undefined
+							? loadingContent("Benchmarks")
+							: createBenchmarkPanel(
+									state.benchmarks,
+									deps.benchmarks.currentIdentity,
+									theme,
+									(action) => done({ kind: "benchmarks", action }),
+									false,
+								),
+				},
+				{
+					key: "cache" as const,
+					label: "Cache",
+					content:
+						state.cache === undefined
+							? loadingContent("Cache")
+							: createCacheEconomicsPanel(state.cache, theme, (action) => done({ kind: "cache", action }), false),
+				},
+			];
+			const container = new TabbedContainer({
+				tabs,
+				theme: tabBarTheme(theme),
+				initialKey: activeKey,
+				measure: hostTextMeasure,
+				onChange: (key) => {
+					activeKey = key as JittorTabKey;
+					done({ kind: "tab-changed" });
+				},
+			});
+			const outer = new BorderedSelectPanel({
+				title: "Jittor",
+				list: container,
+				helpText: "Tab/Shift+Tab switch tabs \u00b7 Esc close",
+				theme: {
+					border: (text) => theme.fg("borderMuted", text),
+					title: theme.bold,
+					help: (text) => theme.fg("dim", text),
+				},
+				measure: hostTextMeasure,
+			});
+			return {
+				invalidate: () => outer.invalidate(),
+				render: (width: number) => outer.render(width),
+				handleInput(data: string): void {
+					if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+						done({ kind: "close" });
+						return;
+					}
+					outer.handleInput(data);
+					tui.requestRender();
+				},
+			};
+		});
+		if (!outcome || outcome.kind === "close") return;
+		if (outcome.kind === "tab-changed") continue;
+		if (outcome.kind === "settings") {
+			await runSettingsAction(
+				ctx,
+				outcome.action,
+				deps.settings.enforcement,
+				deps.settings.recovery,
+				deps.settings.budgets,
+				deps.settings.effects,
+			);
+			continue;
+		}
+		if (outcome.kind === "status") {
+			await runStatusAction(
+				ctx,
+				deps.status.client,
+				outcome.action,
+				state.status as StatusPanelSnapshot,
+				ctx.sessionManager.getSessionId(),
+			);
+			state.status = undefined;
+			continue;
+		}
+		if (outcome.kind === "benchmarks") {
+			if (outcome.action === "refresh") await deps.benchmarks.client.call("benchmark.refresh", { force: true });
+			state.benchmarks = undefined;
+			continue;
+		}
+		// "cache": refresh has no separate daemon mutation -- looping back to refetch is the whole effect.
+		state.cache = undefined;
+	}
+}