pi-squire 0.14.0 → 0.16.0

package/src/widget-data.ts

@@ -0,0 +1,147 @@
+// Read-only direct-child adapter. Results remains the task/result authority.
+// Rows are keyed by native session id, never by a mutable title or launch id.
+import { isStarted, locateSession, type Results, recordedName, type StartedRecorded, sessionIdOf } from "./results.ts";
+import { sessionIsOwned } from "./session-owner.ts";
+import type { TmuxWindow } from "./tmux.ts";
+import type { Activity } from "./widget-activity.ts";
+import { WidgetTitleMirrors } from "./widget-title.ts";
+import { WidgetTitleFiles } from "./widget-title-file.ts";
+import { windowState } from "./windows.ts";
+
+export type DelegateRow = {
+	key: string;
+	sessionId: string;
+	launchId: string;
+	identity: string;
+	title: string | undefined;
+	state: string;
+	running: boolean;
+	window: "open" | "gone" | "unknown";
+	model: string;
+	/** Transcript mtime is a last-active hint, not proof of tool activity. */
+	lastActive: number | undefined;
+	activity?: Activity;
+	summary?: string;
+};
+
+/** All eligible rows remain available; only this viewport incurs metadata I/O. */
+export type MetadataViewport = { offset: number; limit: number };
+type Metadata = {
+	titles: Pick<WidgetTitleFiles, "read" | "clear">;
+	mirrors: Pick<WidgetTitleMirrors, "read" | "clear">;
+	locate: typeof locateSession;
+};
+type Located = { locator: string; path: string };
+type Entry = { record: StartedRecorded; row: DelegateRow };
+
+function candidates(results: Results): StartedRecorded[] {
+	const sessions = new Map<string, StartedRecorded>();
+	for (const record of results.list()) {
+		if (!isStarted(record)) continue;
+		const key: string = sessionIdOf(record);
+		sessions.delete(key);
+		sessions.set(key, record);
+	}
+	return [...sessions.values()].reverse().filter((record) => !record.closed);
+}
+
+/** Independently refreshable metadata cache, with no writes to Results or shared accounting. */
+export class DirectDelegateView {
+	private readonly metadata: Metadata;
+	private readonly paths = new Map<string, Located>();
+
+	constructor(metadata: Partial<Metadata> = {}) {
+		this.metadata = {
+			titles: new WidgetTitleFiles(),
+			mirrors: new WidgetTitleMirrors(),
+			locate: locateSession,
+			...metadata,
+		};
+	}
+
+	clear(): void {
+		this.metadata.titles.clear();
+		this.metadata.mirrors.clear();
+		this.paths.clear();
+	}
+
+	needsWindows(results: Results): boolean {
+		return candidates(results).some((record) => {
+			if (!record.gone || record.result) return true;
+			try {
+				return sessionIsOwned(sessionIdOf(record));
+			} catch {
+				return false;
+			}
+		});
+	}
+
+	read(
+		results: Results,
+		windows: TmuxWindow[] | undefined,
+		sessionDir: string | undefined,
+		viewport: MetadataViewport = { offset: 0, limit: 3 },
+		currentWindows: ReadonlyMap<string, { windowId: string; windowName: string }> = new Map(),
+	): DelegateRow[] {
+		const running: Set<string> = new Set(results.running().map((record) => record.id));
+		const entries: Entry[] = [];
+		for (const saved of candidates(results)) {
+			const current = currentWindows.get(saved.id);
+			const record: StartedRecorded = current ? { ...saved, ...current } : saved;
+			if (record.gone && !record.result && !current) continue;
+			// A verified exact live pane wins over list-windows pane_dead for another active pane.
+			const window = current ? "open" : windowState(windows, record);
+			const working: boolean = running.has(record.id);
+			if (window === "gone" || (!working && ((!record.result && !current) || window !== "open"))) continue;
+			entries.push({ record, row: this.row(record, working, window) });
+		}
+		const ordered: Entry[] = [
+			...entries.filter(({ row }) => row.running),
+			...entries.filter(({ row }) => !row.running),
+		];
+		return ordered.map(({ record, row }, index) => {
+			if (index >= viewport.offset && index < viewport.offset + viewport.limit) this.enrich(record, row, sessionDir);
+			return row;
+		});
+	}
+
+	private row(record: StartedRecorded, running: boolean, window: DelegateRow["window"]): DelegateRow {
+		const sessionId: string = sessionIdOf(record);
+		return {
+			key: sessionId,
+			sessionId,
+			launchId: record.id,
+			identity: recordedName(record),
+			title: undefined,
+			lastActive: undefined,
+			state: running ? "running" : (record.result?.status ?? (record.gone ? "missing" : "unknown")),
+			running,
+			window,
+			model: record.result?.finishedModel ?? record.model,
+		};
+	}
+
+	private path(record: StartedRecorded, sessionDir: string | undefined): string | undefined {
+		const locator: string = JSON.stringify([
+			sessionIdOf(record),
+			record.sessionPath,
+			record.result?.sessionPath,
+			record.sessionDir,
+			sessionDir,
+		]);
+		const cached: Located | undefined = this.paths.get(record.id);
+		if (cached?.locator === locator) return cached.path;
+		const path: string | undefined = this.metadata.locate({ ...record }, sessionDir);
+		if (path) this.paths.set(record.id, { locator, path });
+		else this.paths.delete(record.id); // No negative cache: first transcript flush must become discoverable.
+		return path;
+	}
+
+	private enrich(record: StartedRecorded, row: DelegateRow, sessionDir: string | undefined): void {
+		const disk = this.metadata.titles.read(this.path(record, sessionDir), row.sessionId);
+		if (!disk) this.paths.delete(record.id); // Missing/replaced/mismatched files are rediscovered next refresh.
+		const name: string | undefined = disk?.name ?? this.metadata.mirrors.read(row.sessionId);
+		row.title = name && name !== row.identity ? name : undefined;
+		row.lastActive = disk?.modified;
+	}
+}

package/src/widget-focus.ts

@@ -0,0 +1,133 @@
+// Pi 1.4.0 compatibility adapter: replace this module when Pi exposes prompt-scoped input.
+// No editor/footer replacement, private focusedComponent access or fail-open shape guesses.
+import { CustomEditor, type ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { isKeyRelease, matchesKey } from "@earendil-works/pi-tui";
+import type { WidgetSelection } from "./widget-selection.ts";
+
+type PromptUI = Pick<ExtensionUIContext, "getEditorText" | "getEditorComponent">;
+type PromptState = "empty" | "text" | "other";
+type FocusGetter = { getFocusedComponent(): unknown };
+
+/** Exact class identity was checked through the installed 1.4.0 bundled CLI/jiti loader. */
+export function promptState(tui: unknown, ui: PromptUI): PromptState {
+	try {
+		if (!tui || typeof (tui as Partial<FocusGetter>).getFocusedComponent !== "function") return "other";
+		const focused: unknown = (tui as FocusGetter).getFocusedComponent();
+		if (!focused || Object.getPrototypeOf(focused) !== CustomEditor.prototype) return "other";
+		if (ui.getEditorComponent() !== undefined) return "other";
+		const editor: CustomEditor = focused as CustomEditor;
+		if (typeof editor.isShowingAutocomplete !== "function" || editor.isShowingAutocomplete() !== false) return "other";
+		return ui.getEditorText() === "" ? "empty" : "text";
+	} catch {
+		return "other";
+	}
+}
+
+type InputUI = Pick<ExtensionUIContext, "onTerminalInput" | "getEditorText" | "getEditorComponent">;
+type FocusOptions = {
+	ui: InputUI;
+	selection: WidgetSelection;
+	changed(): void;
+	open(key: string): Promise<void>;
+	error(error: unknown): void;
+};
+
+/** Pseudo-focus: real Pi focus stays with the prompt until Pi mounts a dashboard/dialog. */
+export class WidgetFocus {
+	private readonly options: FocusOptions;
+	private tui: unknown;
+	private unsubscribe: (() => void) | undefined;
+	private busy = false;
+	private suspended = false;
+	private stopped = false;
+
+	constructor(options: FocusOptions) {
+		this.options = options;
+	}
+
+	start(): void {
+		if (this.stopped || this.unsubscribe) return;
+		this.unsubscribe = this.options.ui.onTerminalInput((data) => this.input(data));
+	}
+
+	attach(tui: unknown): void {
+		// InteractiveMode injects a stable proxy which follows regular/fullscreen replacement.
+		this.tui = tui;
+	}
+
+	get focused(): boolean {
+		return (
+			!this.stopped &&
+			!this.busy &&
+			!this.suspended &&
+			this.options.selection.active &&
+			promptState(this.tui, this.options.ui) === "empty"
+		);
+	}
+
+	suspend(suspended: boolean): void {
+		if (this.stopped) return;
+		this.suspended = suspended;
+		// Our own dashboard keeps selection; unrelated prompts relinquish pseudo-focus.
+		if (suspended && !this.busy) this.options.selection.leave();
+		this.options.changed();
+	}
+
+	stop(): void {
+		this.stopped = true;
+		this.unsubscribe?.();
+		this.unsubscribe = undefined;
+		this.tui = undefined;
+	}
+
+	private leave(): void {
+		if (!this.options.selection.active) return;
+		this.options.selection.leave();
+		this.options.changed();
+	}
+
+	private input(data: string): { consume: true } | undefined {
+		if (this.stopped || isKeyRelease(data)) return;
+		// Async listing/action loops temporarily return focus to the prompt. Do not
+		// let dashboard Escape abort a run or action letters leak into that editor.
+		if (this.busy) return this.pendingInput();
+		if (this.suspended || promptState(this.tui, this.options.ui) !== "empty") {
+			this.leave();
+			return;
+		}
+		const selection: WidgetSelection = this.options.selection;
+		if (!selection.active) {
+			if (!matchesKey(data, "down") || !selection.enter()) return;
+		} else if (matchesKey(data, "down")) selection.move(1);
+		else if (matchesKey(data, "up")) selection.move(-1);
+		else if (matchesKey(data, "escape")) selection.leave();
+		else if (matchesKey(data, "enter")) this.open();
+		else {
+			this.leave();
+			return;
+		}
+		this.options.changed();
+		return { consume: true };
+	}
+
+	private pendingInput(): { consume: true } | undefined {
+		return promptState(this.tui, this.options.ui) === "empty" ? { consume: true } : undefined;
+	}
+
+	private open(): void {
+		const key: string | undefined = this.options.selection.selectedKey;
+		if (key === undefined) return;
+		this.busy = true; // Set before invoking async custom UI; repeated Enter cannot reenter.
+		void Promise.resolve()
+			.then(() => {
+				if (!this.stopped) return this.options.open(key);
+			})
+			.catch((error: unknown) => {
+				if (!this.stopped) this.options.error(error);
+			})
+			.finally(() => {
+				this.busy = false;
+				if (!this.stopped) this.options.changed();
+			});
+	}
+}

package/src/widget-live-process.ts

@@ -0,0 +1,31 @@
+import { execFile } from "node:child_process";
+
+export type ProcessIdentity = { pid: number; processStart: string };
+export type Liveness = "live" | "dead" | "unknown";
+
+export function processStart(pid: number): Promise<string | undefined> {
+	return new Promise((resolve) => {
+		// lstart is formatted text: publisher and reader must use the same locale/time zone.
+		execFile(
+			"ps",
+			["-o", "lstart=", "-p", String(pid)],
+			{ timeout: 1000, maxBuffer: 4096, env: { ...process.env, LC_ALL: "C", TZ: "UTC" } },
+			(error, stdout) => {
+				resolve(error ? undefined : stdout.trim() || undefined);
+			},
+		);
+	});
+}
+
+/** Only ESRCH or a successfully observed different start token proves a dead generation. */
+export async function processLiveness(owner: ProcessIdentity): Promise<Liveness> {
+	try {
+		process.kill(owner.pid, 0);
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ESRCH") return "dead";
+		return "unknown";
+	}
+	const start: string | undefined = await processStart(owner.pid);
+	if (start === undefined) return "unknown";
+	return start === owner.processStart ? "live" : "dead";
+}

package/src/widget-live.ts

@@ -0,0 +1,356 @@
+// Private disposable telemetry, never a registry, owner lock or result store.
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir, open, opendir, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { matchesSessionOwner } from "./session-owner.ts";
+import type { PaneLocator } from "./tmux.ts";
+import { type Activity, activityText } from "./widget-activity.ts";
+import { type Liveness, processLiveness, processStart } from "./widget-live-process.ts";
+
+export const LIVE_LAUNCH_ENV = "PI_SQUIRE_LIVE_LAUNCH";
+export const LIVE_MAX_BYTES = 8192;
+export const LIVE_MAX_GENERATIONS = 16;
+type Seed = { version: 1; sessionId: string; launchId: string };
+export type LiveLocator = {
+	locator: PaneLocator;
+	generation: string;
+	ownerToken: string;
+	pid: number;
+	sessionFile?: string;
+};
+type Snapshot = {
+	ownerToken?: string;
+	locator?: PaneLocator;
+	sessionFile?: string;
+	version: 1;
+	sessionId: string;
+	launchId?: string;
+	generation: string;
+	pid: number;
+	processStart: string;
+	revision: number;
+	observedAt: number;
+	activity: Activity | null;
+};
+
+export function liveLaunch(seed: string | undefined, sessionId: string): string | undefined {
+	try {
+		if (!seed || seed.length > 4096) return;
+		const value: Partial<Seed> = JSON.parse(seed);
+		if (value.version === 1 && value.sessionId === sessionId && validString(value.launchId)) return value.launchId;
+	} catch {
+		// Missing/invalid launch correlation is unavailable, never inferred from stable identity.
+	}
+	return;
+}
+
+function validString(value: unknown): value is string {
+	return typeof value === "string" && value.length > 0 && Buffer.byteLength(value) <= 512;
+}
+
+export function liveSessionDir(sessionId: string, agentDir = getAgentDir()): string {
+	return join(agentDir, "squire", "live-sessions", createHash("sha256").update(sessionId).digest("hex"));
+}
+
+async function remove(path: string): Promise<void> {
+	await unlink(path).catch(() => {});
+}
+
+function validActivity(value: unknown): value is Activity | null {
+	if (value === null) return true;
+	if (!value || typeof value !== "object") return false;
+	const activity = value as Partial<Activity>;
+	return (
+		(activity.kind === "tools" || activity.kind === "response") &&
+		typeof activity.text === "string" &&
+		Buffer.byteLength(activity.text) <= 512
+	);
+}
+
+function validLocator(value: PaneLocator | undefined): boolean {
+	if (value === undefined) return true;
+	return (
+		!!value &&
+		validString(value.socket) &&
+		Number.isSafeInteger(value.serverPid) &&
+		value.serverPid > 0 &&
+		validString(value.serverStarted) &&
+		/^%[0-9]+$/.test(value.paneId) &&
+		/^@[0-9]+$/.test(value.windowId) &&
+		typeof value.windowName === "string" &&
+		Buffer.byteLength(value.windowName) <= 512 &&
+		typeof value.exited === "boolean"
+	);
+}
+
+function validSnapshot(value: Partial<Snapshot>, sessionId: string, generation: string): value is Snapshot {
+	return (
+		validLocator(value.locator) &&
+		(value.ownerToken === undefined || validString(value.ownerToken)) &&
+		(value.sessionFile === undefined || validString(value.sessionFile)) &&
+		value.version === 1 &&
+		value.sessionId === sessionId &&
+		value.generation === generation &&
+		validString(value.sessionId) &&
+		(value.launchId === undefined || validString(value.launchId)) &&
+		Number.isSafeInteger(value.pid) &&
+		(value.pid ?? 0) > 0 &&
+		validString(value.processStart) &&
+		Number.isSafeInteger(value.revision) &&
+		(value.revision ?? -1) >= 0 &&
+		typeof value.observedAt === "number" &&
+		Number.isFinite(value.observedAt) &&
+		validActivity(value.activity)
+	);
+}
+
+async function readSnapshot(path: string, sessionId: string, generation: string): Promise<Snapshot | undefined> {
+	try {
+		const file = await open(path, "r");
+		try {
+			const buffer = Buffer.alloc(LIVE_MAX_BYTES + 1);
+			const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+			if (bytesRead > LIVE_MAX_BYTES) return;
+			const value: unknown = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+			if (value && typeof value === "object" && validSnapshot(value, sessionId, generation)) return value;
+		} finally {
+			await file.close();
+		}
+	} catch {
+		// Optional metadata is unavailable.
+	}
+	return;
+}
+
+function uniqueSnapshot(live: Snapshot[], uncertain: boolean): Snapshot | undefined {
+	return !uncertain && live.length === 1 ? live[0] : undefined;
+}
+function snapshotFile(name: string, file: boolean): boolean {
+	return file && /^[a-f0-9-]{36}\.json$/.test(name);
+}
+
+type Probe = (owner: { pid: number; processStart: string }) => Promise<Liveness>;
+
+export class LiveActivityReader {
+	private readonly agentDir: string;
+	private readonly probe: Probe;
+
+	constructor(agentDir = getAgentDir(), probe: Probe = processLiveness) {
+		this.agentDir = agentDir;
+		this.probe = probe;
+	}
+
+	async read(sessionId: string, launchId: string): Promise<Activity | undefined> {
+		try {
+			// Cheap absence fast path preserves prompt initial rows; never negatively cache first publication.
+			if (!existsSync(liveSessionDir(sessionId, this.agentDir))) return;
+			const value: Snapshot | undefined = await this.readSession(sessionId);
+			return value ? this.project(value, launchId) : undefined;
+		} catch {
+			return;
+		}
+	}
+
+	/** Stable-session navigation is independent of launch-correlated task activity. */
+	async locator(sessionId: string): Promise<LiveLocator | undefined> {
+		try {
+			if (!existsSync(liveSessionDir(sessionId, this.agentDir))) return;
+			const value: Snapshot | undefined = await this.readSession(sessionId);
+			if (
+				!value?.locator ||
+				!value.ownerToken ||
+				value.locator.exited ||
+				!matchesSessionOwner(sessionId, value.pid, value.ownerToken)
+			)
+				return;
+			return {
+				locator: value.locator,
+				generation: value.generation,
+				ownerToken: value.ownerToken,
+				pid: value.pid,
+				sessionFile: value.sessionFile,
+			};
+		} catch {
+			return;
+		}
+	}
+
+	private async readSession(sessionId: string): Promise<Snapshot | undefined> {
+		const dir: string = liveSessionDir(sessionId, this.agentDir);
+		const directory = await opendir(dir);
+		const live: Snapshot[] = [];
+		let entries = 0;
+		let uncertain = false;
+		for await (const entry of directory) {
+			if (++entries > LIVE_MAX_GENERATIONS) return;
+			if (!snapshotFile(entry.name, entry.isFile())) continue;
+			const generation: string = entry.name.slice(0, -5);
+			const path: string = join(dir, entry.name);
+			const value: Snapshot | undefined = await readSnapshot(path, sessionId, generation);
+			if (!value) {
+				uncertain = true;
+				continue;
+			}
+			const verdict: Liveness = await this.probe(value);
+			if (verdict === "dead") await remove(path);
+			else if (verdict === "live") live.push(value);
+			else uncertain = true;
+		}
+		return uniqueSnapshot(live, uncertain);
+	}
+
+	private project(value: Snapshot, launchId: string): Activity | undefined {
+		if (value.launchId !== launchId || !value.activity) return;
+		const text: string = activityText(value.activity.text);
+		return text ? { kind: value.activity.kind, text } : undefined;
+	}
+}
+
+type PublisherOptions = {
+	start?: () => Promise<string | undefined>;
+	rename?: typeof rename;
+};
+
+/** At most one pending snapshot and one in-flight write; stop never blocks task delivery. */
+export class LiveActivityPublisher {
+	readonly generation: string = randomUUID();
+	private readonly sessionId: string;
+	private readonly launchId: string | undefined;
+	private readonly dir: string;
+	private readonly path: string;
+	private readonly temporary: string;
+	private readonly start: Promise<string | undefined>;
+	private readonly replace: typeof rename;
+	private activity: Activity | null = null;
+	private locator: PaneLocator | undefined;
+	private locatorKey: string | undefined;
+	private ownerToken: string | undefined;
+	private sessionFile: string | undefined;
+	private revision = 0;
+	private observedAt = Date.now();
+	private dirty = false;
+	private urgent = false;
+	private lastWrite = 0;
+	private stopped = false;
+	private timer: ReturnType<typeof setTimeout> | undefined;
+	private writing: Promise<void> | undefined;
+
+	constructor(sessionId: string, launchId?: string, options: PublisherOptions = {}) {
+		this.sessionId = sessionId;
+		this.launchId = launchId;
+		this.dir = liveSessionDir(sessionId);
+		this.path = join(this.dir, `${this.generation}.json`);
+		this.temporary = `${this.path}.tmp`;
+		this.start = (options.start ?? ((): Promise<string | undefined> => processStart(process.pid)))().catch(
+			() => undefined,
+		);
+		this.replace = options.rename ?? rename;
+	}
+
+	publishLocator(locator: PaneLocator | undefined, ownerToken: string, sessionFile?: string): void {
+		const key: string = JSON.stringify([locator, ownerToken, sessionFile]);
+		if (this.stopped || key === this.locatorKey) return;
+		this.locatorKey = key;
+		this.locator = locator ? { ...locator } : undefined;
+		this.ownerToken = ownerToken;
+		this.sessionFile = sessionFile;
+		this.publish(this.activity ?? undefined);
+	}
+
+	publish(activity: Activity | undefined, immediate = true): void {
+		if (this.stopped) return;
+		this.activity = activity ? { kind: activity.kind, text: activityText(activity.text) } : null;
+		this.revision++;
+		this.observedAt = Date.now();
+		this.dirty = true;
+		this.urgent ||= immediate;
+		if (immediate && this.timer) {
+			clearTimeout(this.timer);
+			this.timer = undefined;
+		}
+		this.schedule();
+	}
+
+	private schedule(): void {
+		if (this.stopped || !this.dirty || this.timer || this.writing) return;
+		this.timer = setTimeout(
+			() => {
+				this.timer = undefined;
+				void this.flush();
+			},
+			this.urgent ? 0 : Math.max(0, 250 - (Date.now() - this.lastWrite)),
+		);
+		this.timer.unref();
+	}
+
+	async flush(): Promise<void> {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = undefined;
+		if (this.writing) return this.writing;
+		this.writing = this.drain().finally(() => {
+			this.writing = undefined;
+			this.schedule();
+		});
+		return this.writing;
+	}
+
+	stop(): void {
+		if (this.stopped) return;
+		this.stopped = true;
+		this.dirty = false;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = undefined;
+		void this.closed();
+	}
+
+	async closed(): Promise<void> {
+		await this.writing;
+		if (this.stopped) await Promise.all([remove(this.path), remove(this.temporary)]);
+	}
+
+	private async drain(): Promise<void> {
+		const start: string | undefined = await this.start;
+		if (!start || this.stopped) {
+			this.dirty = false;
+			return;
+		}
+		if (this.dirty && !this.stopped) {
+			this.dirty = false;
+			this.urgent = false;
+			this.lastWrite = Date.now();
+			const snapshot: Snapshot = {
+				version: 1,
+				sessionId: this.sessionId,
+				launchId: this.launchId,
+				generation: this.generation,
+				pid: process.pid,
+				processStart: start,
+				revision: this.revision,
+				observedAt: this.observedAt,
+				activity: this.activity,
+				locator: this.locator,
+				ownerToken: this.ownerToken,
+				sessionFile: this.sessionFile,
+			};
+			await this.write(snapshot);
+		}
+	}
+
+	private async write(snapshot: Snapshot): Promise<void> {
+		try {
+			const json: string = JSON.stringify(snapshot);
+			if (Buffer.byteLength(json) > LIVE_MAX_BYTES) return;
+			await mkdir(this.dir, { recursive: true, mode: 0o700 });
+			await writeFile(this.temporary, json, { mode: 0o600 });
+			if (!this.stopped) await this.replace(this.temporary, this.path);
+		} catch {
+			// A newer queued revision owns its key and already has a pending write.
+			if (snapshot.revision === this.revision) this.locatorKey = undefined;
+			await remove(this.path);
+		} finally {
+			await remove(this.temporary);
+		}
+	}
+}