@quandev104/pi-style 0.1.1

package/extension-src/pi-style/app/index.ts

@@ -0,0 +1,322 @@
+import { boundedDiagnostics } from "../domain/config-diagnostics.js";
+import { DEFAULT_CONFIG, normalizeConfig, resolveConfigDetailed } from "../domain/config-normalization.js";
+import type { NormalizedPiStyleConfig } from "../domain/config-types.js";
+import type { StartupDetailItem, StartupReason } from "../features/startup/index.js";
+import { createDoctor, type DoctorOperationalState } from "./doctor.js";
+import { PiStyleRuntimeController } from "./runtime.js";
+
+export interface StartupResourceDiscovery {
+	readonly skillPaths?: readonly string[];
+	readonly promptPaths?: readonly string[];
+	readonly themePaths?: readonly string[];
+	/** Raw system prompt text; word/line counts are computed outside render. */
+	readonly systemPrompt?: string;
+	/** Context files with pre-computed word/line counts (discovery outside render). */
+	readonly contextDetails?: readonly { path: string; words: number; lines: number }[];
+	/** Active tools with compact source labels (discovery outside render). */
+	readonly toolDetails?: readonly { source: string; name: string }[];
+	readonly models?: number;
+}
+
+function countWords(text: string): number {
+	return text.match(/[\p{L}\p{N}_]+/gu)?.length ?? 0;
+}
+
+function countLines(text: string): number {
+	if (text.length === 0) return 0;
+	const lines = text.split(/\r\n|\r|\n/).length;
+	return /\r\n$|\r$|\n$/.test(text) ? lines - 1 : lines;
+}
+
+function toStartupResources(resources: StartupResourceDiscovery) {
+	const details: StartupDetailItem[] = [];
+	if (resources.systemPrompt) {
+		const words = countWords(resources.systemPrompt);
+		const lines = countLines(resources.systemPrompt);
+		if (words > 0 && lines > 0) details.push({ kind: "system", path: "system prompt", words, lines });
+	}
+	for (const file of resources.contextDetails ?? []) {
+		if (file.words > 0 && file.lines > 0) {
+			details.push({ kind: "context", path: file.path, words: file.words, lines: file.lines });
+		}
+	}
+	return {
+		...(resources.promptPaths ? { contextFiles: resources.promptPaths.length } : {}),
+		...(resources.themePaths ? { extensions: resources.themePaths.length } : {}),
+		...(resources.skillPaths ? { skills: resources.skillPaths.length } : {}),
+		...(resources.models !== undefined ? { models: resources.models } : {}),
+		...(resources.toolDetails && resources.toolDetails.length > 0
+			? { tools: resources.toolDetails.length, toolDetails: resources.toolDetails }
+			: {}),
+		...(details.length > 0 ? { details } : {}),
+	};
+}
+
+export interface ConfigReloadPort {
+	load(trusted: boolean): Promise<{
+		readonly config?: unknown;
+		readonly diagnostics?: readonly import("../domain/config-diagnostics.js").ConfigDiagnostic[];
+		readonly sources?: Readonly<Record<string, string>>;
+		readonly rawSources?: {
+			defaults?: unknown;
+			global?: unknown;
+			project?: unknown;
+			environment?: Record<string, string | undefined>;
+		};
+		readonly productPolicy?: { corePatchGate: "omitted" | "allow" | "deny" };
+	}>;
+}
+
+export interface AppHost {
+	readonly mode: "tui" | "rpc" | "json" | "print";
+	readonly hasUI: boolean;
+	readonly ui?: Parameters<PiStyleRuntimeController["start"]>[0]["ui"];
+	readonly cwd?: string;
+	readonly model?: { id?: string; name?: string; provider?: string; reasoning?: boolean };
+	readonly thinkingLevel?: string;
+	readonly getContextUsage?: () => { tokens: number | null; contextWindow: number; percent: number | null } | undefined;
+	readonly projectTrusted?: boolean;
+	readonly extensionStatusProvider?: () => readonly import("../domain/status.js").ExtensionStatus[] | undefined;
+	readonly gitRunner?: import("../domain/providers.js").GitCommandRunner;
+}
+
+export interface PiStyleApp {
+	readonly runtime: PiStyleRuntimeController;
+	readonly config: NormalizedPiStyleConfig;
+	readonly productPolicy: { corePatchGate: "omitted" | "allow" | "deny" };
+	sessionStart(ctx: AppHost, reason?: StartupReason, resources?: StartupResourceDiscovery): void;
+	setResources(resources: StartupResourceDiscovery): void;
+	applySession(patch: unknown): void;
+	setProjectTrusted(trusted: boolean): void;
+	setOperationalState(state: DoctorOperationalState): void;
+	setProductPolicy(policy: { corePatchGate: "omitted" | "allow" | "deny" }): void;
+	reload(): Promise<void>;
+	doctor(): Readonly<Record<string, unknown>>;
+	sessionShutdown(): void;
+	update(
+		values: import("../domain/status.js").StatusSnapshot,
+		kind?: import("./render-scheduler.js").UpdateClass,
+	): void;
+}
+
+function submittedSessionPaths(value: unknown, prefix = ""): readonly string[] {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+	return Object.entries(value).flatMap(([key, nested]) => {
+		const path = prefix ? `${prefix}.${key}` : key;
+		return [path, ...submittedSessionPaths(nested, path)];
+	});
+}
+function composeSources(
+	durable: Readonly<Record<string, string>>,
+	resolved: Readonly<Record<string, string>>,
+	session: unknown,
+): Readonly<Record<string, string>> {
+	const next = { ...durable, ...resolved };
+	for (const path of submittedSessionPaths(session)) {
+		const effectiveSource = resolved[path];
+		if (effectiveSource === undefined) delete next[path];
+		else next[path] = effectiveSource;
+	}
+	return next;
+}
+
+function mergePatch(base: unknown, patch: unknown): unknown {
+	if (patch === undefined) return base;
+	if (
+		typeof base !== "object" ||
+		base === null ||
+		Array.isArray(base) ||
+		typeof patch !== "object" ||
+		patch === null ||
+		Array.isArray(patch)
+	)
+		return patch;
+	const result: Record<string, unknown> = { ...(base as Record<string, unknown>) };
+	for (const [key, value] of Object.entries(patch as Record<string, unknown>))
+		result[key] = mergePatch(result[key], value);
+	return result;
+}
+
+export function createPiStyleApp(
+	initialConfig?: unknown,
+	reloadPort?: ConfigReloadPort,
+	onConfigChange?: (config: NormalizedPiStyleConfig) => void,
+): PiStyleApp {
+	const runtime = new PiStyleRuntimeController();
+	let config = initialConfig === undefined ? DEFAULT_CONFIG : normalizeConfig(initialConfig);
+	let diagnostics: readonly import("../domain/config-diagnostics.js").ConfigDiagnostic[] = [];
+	let durableDiagnostics: readonly import("../domain/config-diagnostics.js").ConfigDiagnostic[] = [];
+	let durableSources: Readonly<Record<string, string>> = {};
+	let sources: Readonly<Record<string, string>> = {};
+	let trusted = true;
+	let resources: StartupResourceDiscovery | undefined;
+	let operational: DoctorOperationalState = {};
+	let sessionPatch: unknown;
+	let rawSources: {
+		defaults?: unknown;
+		global?: unknown;
+		project?: unknown;
+		environment?: Record<string, string | undefined>;
+	} = { defaults: initialConfig ?? DEFAULT_CONFIG };
+	let productPolicy: { corePatchGate: "omitted" | "allow" | "deny" } = { corePatchGate: "omitted" };
+	const resolveAll = () => resolveConfigDetailed({ ...rawSources, session: sessionPatch, projectTrusted: trusted });
+	const resolveProductPolicy = () => {
+		const values = [rawSources.global, trusted ? rawSources.project : undefined, sessionPatch];
+		for (const value of values) {
+			if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+			const compatibility = (value as Record<string, unknown>).compatibility;
+			if (
+				compatibility &&
+				typeof compatibility === "object" &&
+				!Array.isArray(compatibility) &&
+				Object.hasOwn(compatibility, "allowCorePatches") &&
+				(compatibility as Record<string, unknown>).allowCorePatches === false
+			)
+				return { corePatchGate: "deny" as const };
+		}
+		return { corePatchGate: "omitted" as const };
+	};
+	return {
+		runtime,
+		get config() {
+			return config;
+		},
+		get productPolicy() {
+			return productPolicy;
+		},
+		sessionStart(ctx, reason = "startup", discoveredResources) {
+			trusted = ctx.projectTrusted ?? true;
+			resources = discoveredResources;
+			operational = {
+				...operational,
+				provider: ctx.extensionStatusProvider
+					? { status: "configured", recovery: "provider will be checked on first snapshot" }
+					: { status: "unavailable", recovery: "inject a capability-safe provider" },
+				installations: {
+					status: config.enabled && config.statusLine.enabled ? "active" : "disabled",
+					editor: config.enabled && config.editor.enabled ? "active" : "disabled",
+					startup: config.enabled && config.startup.mode !== "off" ? "active" : "disabled",
+				},
+			};
+			const statusProvider = ctx.extensionStatusProvider
+				? () => {
+						try {
+							const result = ctx.extensionStatusProvider?.();
+							operational = { ...operational, provider: { status: "available" } };
+							return result;
+						} catch {
+							operational = {
+								...operational,
+								provider: { status: "unavailable", recovery: "provider threw; retry after recovery" },
+							};
+							ctx.ui?.notify?.("pi-style extension statuses unavailable; provider recovery required", "warning");
+							return undefined;
+						}
+					}
+				: undefined;
+			runtime.start({
+				mode: ctx.mode,
+				hasUI: ctx.hasUI,
+				...(ctx.ui ? { ui: ctx.ui } : {}),
+				...(ctx.cwd ? { cwd: ctx.cwd } : {}),
+				...(ctx.model ? { model: ctx.model } : {}),
+				...(ctx.thinkingLevel ? { thinkingLevel: ctx.thinkingLevel } : {}),
+				config,
+				startupReason: reason,
+				...(resources ? { resources: toStartupResources(resources) } : {}),
+				...(ctx.getContextUsage ? { getContextUsage: ctx.getContextUsage } : {}),
+				...(ctx.projectTrusted !== undefined ? { projectTrusted: ctx.projectTrusted } : {}),
+				...(ctx.gitRunner ? { gitRunner: ctx.gitRunner } : {}),
+				...(statusProvider ? { extensionStatusProvider: statusProvider } : {}),
+			});
+		},
+		setResources(next) {
+			resources = next;
+			runtime.current?.updateStartupResources(toStartupResources(next));
+		},
+		applySession(patch) {
+			sessionPatch = mergePatch(sessionPatch, patch);
+			const resolved = resolveAll();
+			config = resolved.config;
+			diagnostics = boundedDiagnostics([...durableDiagnostics, ...resolved.diagnostics]);
+			sources = composeSources(durableSources, resolved.sources, sessionPatch);
+			productPolicy = resolveProductPolicy();
+			operational = {
+				...operational,
+				authorization: { ...(operational.authorization ?? {}), productCorePatchGate: productPolicy.corePatchGate },
+			};
+			runtime.current?.configure(config);
+			operational = {
+				...operational,
+				installations: { ...(operational.installations ?? {}), configChange: "reconciled" },
+			};
+			onConfigChange?.(config);
+		},
+		setProjectTrusted(nextTrusted) {
+			trusted = nextTrusted;
+		},
+		setOperationalState(state) {
+			operational = { ...operational, ...state };
+		},
+		setProductPolicy(policy) {
+			productPolicy = policy;
+			operational = {
+				...operational,
+				authorization: { ...(operational.authorization ?? {}), productCorePatchGate: policy.corePatchGate },
+			};
+		},
+		sessionShutdown() {
+			runtime.stop();
+		},
+		update(values, kind = "coalesced") {
+			const active = runtime.current;
+			if (!active) return;
+			active.update(values);
+			active.scheduler.schedule(kind);
+		},
+		reload() {
+			if (!reloadPort) {
+				runtime.current?.configure(config);
+				return Promise.resolve();
+			}
+			return reloadPort.load(trusted).then((result) => {
+				durableDiagnostics = boundedDiagnostics(result.diagnostics ?? []);
+				durableSources = result.sources ?? {};
+				diagnostics = durableDiagnostics;
+				sources = durableSources;
+				if (result.config !== undefined) {
+					rawSources = result.rawSources ?? { defaults: result.config };
+					productPolicy = resolveProductPolicy();
+					const resolved = resolveAll();
+					config = resolved.config;
+					diagnostics = boundedDiagnostics([...durableDiagnostics, ...resolved.diagnostics]);
+					sources = composeSources(durableSources, resolved.sources, sessionPatch);
+					onConfigChange?.(config);
+					operational = {
+						...operational,
+						authorization: { ...(operational.authorization ?? {}), productCorePatchGate: productPolicy.corePatchGate },
+					};
+				}
+				runtime.current?.configure(config);
+				onConfigChange?.(config);
+			});
+		},
+		doctor() {
+			return createDoctor({
+				config,
+				operational,
+				diagnostics,
+				sources,
+				surfaces: {
+					status: operational.installations?.status ?? "unknown",
+					editor: operational.installations?.editor ?? "unknown",
+					startup: operational.installations?.startup ?? "unknown",
+					userMessage: operational.compatibility?.userMessage ?? "unknown",
+					assistantMessage: operational.compatibility?.assistantMessage ?? "unknown",
+					specialBlocks: operational.compatibility?.specialBlocks ?? "unknown",
+					tools: operational.compatibility?.tools ?? "unknown",
+				},
+			});
+		},
+	};
+}

package/extension-src/pi-style/app/providers.ts

@@ -0,0 +1,268 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import type {
+	ContextProvider,
+	GitCommandResult,
+	GitCommandRunner,
+	GitProvider,
+	UsageProvider,
+} from "../domain/providers.js";
+import type { ContextSnapshot, GitSnapshot, UsageSnapshot } from "../domain/status.js";
+
+const execFileAsync = promisify(execFile);
+const EMPTY_USAGE: UsageSnapshot = Object.freeze({
+	inputTokens: 0,
+	outputTokens: 0,
+	cacheReadTokens: 0,
+	cacheWriteTokens: 0,
+	streaming: false,
+	subscriptionMode: "unknown",
+});
+
+export class NodeGitCommandRunner implements GitCommandRunner {
+	async run(args: readonly string[], cwd: string, timeoutMs: number, signal?: AbortSignal): Promise<GitCommandResult> {
+		if (signal?.aborted) return { stdout: "", stderr: "git command aborted", code: 1 };
+		try {
+			const result = await execFileAsync("git", [...args], {
+				cwd,
+				timeout: timeoutMs,
+				maxBuffer: 1024 * 1024,
+				signal,
+			});
+			return { stdout: result.stdout, stderr: result.stderr, code: 0 };
+		} catch (error) {
+			const failure = error as { stdout?: string; stderr?: string; code?: number; signal?: string };
+			return {
+				stdout: failure.stdout ?? "",
+				stderr: failure.stderr ?? (failure.signal ? `git terminated by ${failure.signal}` : "git command failed"),
+				code: failure.code ?? 1,
+			};
+		}
+	}
+}
+
+interface GitEntry {
+	value: GitSnapshot;
+	expiresAt: number;
+	retryAt: number;
+	generation: number;
+	promise?: Promise<GitSnapshot>;
+	controller?: AbortController;
+	needsRefresh?: boolean;
+	resultReady: boolean;
+}
+
+export interface GitProviderStats {
+	readonly entries: number;
+	readonly inFlight: number;
+	readonly refreshes: number;
+	readonly disposed: boolean;
+}
+
+export interface GitProviderClock {
+	now(): number;
+}
+
+export class CachedGitProvider implements GitProvider {
+	private readonly cache = new Map<string, GitEntry>();
+	private disposed = false;
+	private refreshCount = 0;
+	constructor(
+		private readonly runner: GitCommandRunner = new NodeGitCommandRunner(),
+		private readonly ttlMs = 1000,
+		private readonly timeoutMs = 800,
+		private readonly maxBackoffMs = 5000,
+		private readonly clock: GitProviderClock = { now: () => Date.now() },
+	) {}
+	get stats(): GitProviderStats {
+		return {
+			entries: this.cache.size,
+			inFlight: [...this.cache.values()].filter((entry) => entry.promise).length,
+			refreshes: this.refreshCount,
+			disposed: this.disposed,
+		};
+	}
+	async get(cwd: string): Promise<GitSnapshot> {
+		if (this.disposed) return unavailableGit("provider disposed");
+		const now = this.clock.now();
+		const current = this.cache.get(cwd);
+		if (current && current.expiresAt > now && !current.needsRefresh) return current.value;
+		if (current?.promise) return current.resultReady ? current.value : current.promise;
+		if (current && current.retryAt > now) return current.value;
+		const stale = current?.value;
+		const entry: GitEntry = current ?? {
+			value: refreshingGit(),
+			expiresAt: 0,
+			retryAt: 0,
+			generation: 0,
+			resultReady: false,
+		};
+		entry.needsRefresh = false;
+		entry.resultReady = Boolean(stale);
+		entry.value = stale ? { ...stale, refreshing: true } : refreshingGit();
+		entry.controller = new AbortController();
+		entry.promise = this.refresh(cwd, entry, stale, entry.controller.signal);
+		this.cache.set(cwd, entry);
+		return stale ? entry.value : entry.promise;
+	}
+	invalidate(cwd?: string): void {
+		const keys = cwd === undefined ? [...this.cache.keys()] : [cwd];
+		for (const key of keys) {
+			const entry = this.cache.get(key);
+			if (!entry) continue;
+			entry.generation++;
+			entry.expiresAt = 0;
+			if (entry.promise) entry.needsRefresh = true;
+			else this.cache.delete(key);
+		}
+	}
+	dispose(): void {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const entry of this.cache.values()) entry.controller?.abort();
+		this.cache.clear();
+	}
+	private async refresh(
+		cwd: string,
+		entry: GitEntry,
+		stale: GitSnapshot | undefined,
+		signal: AbortSignal,
+	): Promise<GitSnapshot> {
+		this.refreshCount++;
+		const generation = entry.generation;
+		let value: GitSnapshot;
+		try {
+			const result = await this.runner.run(["status", "--porcelain=v1", "--branch"], cwd, this.timeoutMs, signal);
+			if (result.code !== 0) {
+				value = stale
+					? { ...stale, refreshing: false, error: result.stderr.trim() || "git status failed" }
+					: unavailableGit(result.stderr.trim() || "git status failed");
+			} else value = parseGitStatus(result.stdout);
+		} catch (error) {
+			value = stale ? { ...stale, refreshing: false, error: String(error) } : unavailableGit(String(error));
+		}
+		if (this.disposed || this.cache.get(cwd) !== entry) return value;
+		const invalidated = entry.generation !== generation || entry.needsRefresh;
+		delete entry.promise;
+		delete entry.controller;
+		entry.value = value;
+		entry.resultReady = true;
+		if (invalidated) {
+			entry.needsRefresh = false;
+			entry.expiresAt = 0;
+			void this.get(cwd);
+			return value;
+		}
+		entry.retryAt = value.error ? this.clock.now() + Math.min(this.maxBackoffMs, Math.max(this.ttlMs, 100)) : 0;
+		entry.expiresAt = this.clock.now() + this.ttlMs;
+		if (entry.needsRefresh) {
+			entry.needsRefresh = false;
+			void this.get(cwd);
+		}
+		return value;
+	}
+}
+
+function refreshingGit(): GitSnapshot {
+	return Object.freeze({ available: false, branch: null, staged: 0, unstaged: 0, untracked: 0, refreshing: true });
+}
+function unavailableGit(error: string): GitSnapshot {
+	return Object.freeze({
+		available: false,
+		branch: null,
+		staged: 0,
+		unstaged: 0,
+		untracked: 0,
+		refreshing: false,
+		error,
+	});
+}
+export function parseGitStatus(output: string): GitSnapshot {
+	const lines = output.split("\n").filter(Boolean);
+	const header = lines.find((line) => line.startsWith("## "))?.slice(3) ?? "";
+	if (!header) return unavailableGit("not a git repository");
+	const branch = header.split("...")[0]?.replace(/^HEAD \(no branch\)$/, "detached") ?? null;
+	let staged = 0;
+	let unstaged = 0;
+	let untracked = 0;
+	for (const line of lines) {
+		if (line.startsWith("## ")) continue;
+		if (line.startsWith("??")) {
+			untracked++;
+			continue;
+		}
+		if (line.length < 2) continue;
+		if (line[0] !== " ") staged++;
+		if (line[1] !== " ") unstaged++;
+	}
+	const ahead = /\[ahead (\d+)\]/.exec(header)?.[1];
+	const behind = /\[behind (\d+)\]/.exec(header)?.[1];
+	return Object.freeze({
+		available: true,
+		branch: branch || null,
+		staged,
+		unstaged,
+		untracked,
+		...(ahead ? { ahead: Number(ahead) } : {}),
+		...(behind ? { behind: Number(behind) } : {}),
+		refreshing: false,
+	});
+}
+
+export class InMemoryUsageProvider implements UsageProvider {
+	private readonly values = new Map<string, UsageSnapshot>();
+	private readonly events = new Map<string, Set<string>>();
+	private readonly finalized = new Map<string, Set<string>>();
+	get(sessionId: string): UsageSnapshot {
+		return this.values.get(sessionId) ?? EMPTY_USAGE;
+	}
+	record(
+		sessionId: string,
+		usage: Partial<UsageSnapshot>,
+		options: { eventId?: string; finalized?: boolean } = {},
+	): void {
+		if (options.eventId) {
+			const ids = this.events.get(sessionId) ?? new Set<string>();
+			const finalized = this.finalized.get(sessionId) ?? new Set<string>();
+			if (finalized.has(options.eventId) || (ids.has(options.eventId) && !options.finalized)) return;
+			ids.add(options.eventId);
+			this.events.set(sessionId, ids);
+			if (options.finalized) {
+				finalized.add(options.eventId);
+				this.finalized.set(sessionId, finalized);
+			}
+		}
+		const current = this.get(sessionId);
+		const next = {
+			...current,
+			...usage,
+			streaming: options.finalized ? false : (usage.streaming ?? current.streaming),
+		};
+		this.values.set(sessionId, Object.freeze(next));
+	}
+	reset(sessionId?: string): void {
+		if (sessionId === undefined) {
+			this.values.clear();
+			this.events.clear();
+			this.finalized.clear();
+			return;
+		}
+		this.values.delete(sessionId);
+		this.events.delete(sessionId);
+		this.finalized.delete(sessionId);
+	}
+}
+
+export class InMemoryContextProvider implements ContextProvider {
+	private readonly values = new Map<string, ContextSnapshot>();
+	get(sessionId: string): ContextSnapshot | undefined {
+		return this.values.get(sessionId);
+	}
+	set(sessionId: string, context: ContextSnapshot): void {
+		this.values.set(sessionId, Object.freeze({ ...context }));
+	}
+	clear(sessionId?: string): void {
+		if (sessionId === undefined) this.values.clear();
+		else this.values.delete(sessionId);
+	}
+}

package/extension-src/pi-style/app/render-scheduler.ts

@@ -0,0 +1,48 @@
+export type UpdateClass = "immediate" | "coalesced" | "deferred" | "delayed-retry";
+export interface SchedulerHost {
+	requestRender(): void;
+}
+
+export class RenderScheduler {
+	private stopped = false;
+	private immediateQueued = false;
+	private coalescedTimer: ReturnType<typeof setTimeout> | undefined;
+	private deferredTimer: ReturnType<typeof setTimeout> | undefined;
+	private retryTimer: ReturnType<typeof setTimeout> | undefined;
+	constructor(
+		private readonly host: SchedulerHost,
+		private readonly generation: number,
+		private readonly isCurrent: (generation: number) => boolean = (current) => current === this.generation,
+	) {}
+	schedule(kind: UpdateClass): void {
+		if (this.stopped || !this.isCurrent(this.generation)) return;
+		if (kind === "immediate") {
+			if (this.immediateQueued) return;
+			this.immediateQueued = true;
+			queueMicrotask(() => {
+				this.immediateQueued = false;
+				this.render();
+			});
+			return;
+		}
+		const target = kind === "coalesced" ? "coalescedTimer" : kind === "deferred" ? "deferredTimer" : "retryTimer";
+		if (this[target] !== undefined) return;
+		const delay = kind === "coalesced" ? 16 : kind === "deferred" ? 50 : 100;
+		this[target] = setTimeout(() => {
+			this[target] = undefined;
+			this.render();
+		}, delay);
+	}
+	private render(): void {
+		if (!this.stopped && this.isCurrent(this.generation)) this.host.requestRender();
+	}
+	cancel(): void {
+		this.stopped = true;
+		if (this.coalescedTimer !== undefined) clearTimeout(this.coalescedTimer);
+		if (this.deferredTimer !== undefined) clearTimeout(this.deferredTimer);
+		if (this.retryTimer !== undefined) clearTimeout(this.retryTimer);
+		this.coalescedTimer = undefined;
+		this.deferredTimer = undefined;
+		this.retryTimer = undefined;
+	}
+}