@zetaloop/chappie 0.5.0 → 1.0.0

package/src/session.ts

@@ -1,848 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { access } from "node:fs/promises";
-import { hostname } from "node:os";
-import { resolve } from "node:path";
-import type {
-	AssistantMessage,
-	ToolResultMessage,
-	UserMessage,
-} from "@earendil-works/pi-ai";
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-	SessionEntry,
-} from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import { type Activity, chatLabel, source } from "./activity.ts";
-import type { DeliveryRecord } from "./delivery.ts";
-import { historyResult } from "./history.ts";
-import {
-	type BrokerMessage,
-	IpcClient,
-	type SessionDescription,
-	type SessionInput,
-	type SessionInspection,
-	type SessionRequest,
-	type SessionResult,
-	type SessionStatus,
-} from "./ipc.ts";
-import type { ProviderOutput } from "./provider.ts";
-import {
-	type ResourceDescriptor,
-	readSessionResource,
-	rememberImages,
-	resourceSessionId,
-} from "./resources.ts";
-import { copyFiles, transfer, transferResult } from "./transfer.ts";
-
-type RemoteRequest = Extract<BrokerMessage, { type: "chat" | "call" }>;
-
-interface Notice extends Activity {
-	message: string;
-	type: "info" | "warning" | "error";
-}
-
-interface SyncRequest {
-	resolve(): void;
-	reject(error: Error): void;
-}
-
-interface StoreRequest {
-	resolve(): void;
-	reject(error: Error): void;
-}
-
-interface PendingRequest {
-	resolve(result: SessionResult): void;
-	reject(error: Error): void;
-}
-
-interface HistoryRequest {
-	request: Extract<BrokerMessage, { type: "history" }>;
-	timeout: NodeJS.Timeout;
-}
-
-interface ActiveRequest {
-	request: RemoteRequest;
-	session: SessionDescription;
-	message: AssistantMessage;
-	completed: boolean;
-	cancelled: string | undefined;
-	toolResults: ToolResultMessage[];
-}
-
-export class LocalSession {
-	readonly #pi: ExtensionAPI;
-	readonly #agentDir: string;
-	readonly #connect: string | undefined;
-	readonly #syncs = new Map<number, SyncRequest>();
-	readonly #stores = new Map<string, StoreRequest>();
-	readonly #queue: RemoteRequest[] = [];
-	readonly #pendingInputs = new Map<string, SessionInput>();
-	readonly #deliveries = new Map<string, DeliveryRecord>();
-	readonly #histories = new Map<number, HistoryRequest>();
-	readonly #requests = new Map<number, PendingRequest>();
-	readonly #copies = new Map<number, AbortController>();
-	#context: ExtensionContext | undefined;
-	#connection: IpcClient | undefined;
-	#output: ProviderOutput | undefined;
-	#active: ActiveRequest | undefined;
-	#status: SessionStatus = "idle";
-	#nextRequestId = 1;
-	#starting = false;
-	#sessionId: string | undefined;
-	#inputCursor: string | null = null;
-	#flushing = Promise.resolve();
-
-	constructor(pi: ExtensionAPI, agentDir: string, connect?: string) {
-		this.#pi = pi;
-		this.#agentDir = agentDir;
-		this.#connect = connect;
-	}
-
-	install(): void {
-		this.#pi.registerEntryRenderer<Notice>(
-			"chappie.notice",
-			({ data }, _options, theme) => {
-				if (!data) return;
-				return new Text(
-					theme.fg(data.type === "info" ? "dim" : data.type, data.message),
-					1,
-					0,
-				);
-			},
-		);
-		this.#pi.on("session_start", (_event, context) => this.#update(context));
-		this.#pi.on("model_select", (event, context) =>
-			this.#update(context, event.model.provider === "chappie"),
-		);
-		this.#pi.on("session_info_changed", (_event, context) => {
-			this.#context = context;
-			void this.#sync().catch(() => {});
-		});
-		this.#pi.on("session_tree", (event, context) => {
-			this.#context = context;
-			if (context.model?.provider === "chappie") {
-				this.#resetInputs(context, event.newLeafId);
-			}
-			this.#historyChanged();
-		});
-		// Pi persists messages after message_end handlers finish.
-		this.#pi.on("message_start", (_event, context) => {
-			this.#context = context;
-			this.#historyChanged();
-		});
-		this.#pi.on("tool_call", (_event, context) => {
-			this.#context = context;
-			this.#historyChanged();
-		});
-		this.#pi.on("session_compact", (_event, context) => {
-			this.#context = context;
-			this.#historyChanged();
-		});
-		this.#pi.on("context", (event, context) => ({
-			messages:
-				context.model?.provider === "chappie"
-					? []
-					: event.messages.filter(
-							(message) =>
-								message.role !== "custom" ||
-								message.customType !== "chappie.request",
-						),
-		}));
-		this.#pi.on("turn_end", (event, context) =>
-			this.#turnEnd(event.message, event.toolResults, context),
-		);
-		this.#pi.on("agent_settled", async (_event, context) => {
-			this.#context = context;
-			this.#starting = false;
-			this.#collectInputs();
-			this.#historyChanged();
-			await this.#completeActive();
-			this.#dispatch();
-		});
-		this.#pi.on("session_shutdown", () => this.close());
-	}
-
-	#notify(
-		message: string,
-		type: Notice["type"] = "info",
-		activity: Activity = {},
-	): void {
-		if (this.#context)
-			this.#pi.appendEntry<Notice>("chappie.notice", {
-				message,
-				type,
-				...activity,
-			});
-		if (activity.event !== "history") this.#historyChanged();
-	}
-
-	async start(output: ProviderOutput): Promise<void> {
-		const context = this.#context;
-		const connection = this.#connection;
-		if (context?.model?.provider !== "chappie" || !connection) {
-			throw new Error("Chappie is not active for this session");
-		}
-		if (this.#output && !this.#output.closed) {
-			throw new Error("Chappie already has an active provider request");
-		}
-
-		this.#starting = false;
-		this.#output = output;
-		try {
-			await connection.connect();
-			if (output.closed) return;
-			this.#collectInputs();
-			this.#historyChanged();
-			await this.#completeActive();
-			this.#status = "ready";
-			await this.#sync();
-			if (output.closed) return;
-			output.begin();
-			this.#dispatch();
-			await output.finished;
-		} finally {
-			if (this.#output === output) this.#output = undefined;
-			this.#status = this.#active ? "executing" : "idle";
-			void this.#sync().catch(() => {});
-		}
-	}
-
-	async transfer(
-		...parameters: Parameters<typeof transfer.execute>
-	): ReturnType<typeof transfer.execute> {
-		const [id, args, signal, update, context] = parameters;
-		if (!args.to) return transfer.execute(...parameters);
-		if (args.files) throw new Error("files and to are mutually exclusive");
-		if (args.paths.length !== args.to.paths.length)
-			throw new Error("Source and destination counts must match");
-		const inspected = await this.#request(
-			{ type: "inspect", sessionId: args.to.sessionId },
-			signal,
-		);
-		if (!("inspection" in inspected))
-			throw new Error("Pi session returned no environment");
-		const exported = await transfer.execute(
-			id,
-			{ paths: args.paths },
-			signal,
-			undefined,
-			context,
-		);
-		update?.({
-			content: [],
-			details: {
-				...exported.details,
-				to: {
-					sessionId: args.to.sessionId,
-					device: inspected.inspection.session.device,
-				},
-			},
-		});
-		const result = await this.#request(
-			{
-				type: "copy",
-				sessionId: args.to.sessionId,
-				paths: args.to.paths,
-				resources: exported.details.resources,
-				...(args.overwrite !== undefined ? { overwrite: args.overwrite } : {}),
-			},
-			signal,
-		);
-		if (!("transfer" in result))
-			throw new Error("Pi session returned no transfer result");
-		return transferResult({ ...result.transfer, device: hostname() });
-	}
-
-	close(): void {
-		const sessionId = this.#context?.sessionManager.getSessionId();
-		if (sessionId && this.#connection?.connected) {
-			void this.#connection
-				.send({ type: "unregister", sessionId })
-				.catch(() => {});
-		}
-		this.#output?.fail(new Error("Chappie session ended"), true);
-		this.#output = undefined;
-		this.#active = undefined;
-		this.#queue.length = 0;
-		this.#starting = false;
-		this.#connection?.close();
-		this.#connection = undefined;
-		this.#context = undefined;
-		this.#resetInputs();
-		this.#cancelRequests(new Error("Chappie session ended"));
-		this.#rejectSyncs(new Error("Chappie session ended"));
-		this.#rejectStores(new Error("Chappie session ended"));
-		for (const id of this.#histories.keys()) this.#finishHistory(id);
-	}
-
-	#update(
-		context: ExtensionContext,
-		active = context.model?.provider === "chappie",
-	): void {
-		this.#context = context;
-		if (!active) {
-			this.close();
-			return;
-		}
-		if (this.#sessionId !== context.sessionManager.getSessionId()) {
-			this.#resetInputs(context);
-		}
-		if (!this.#connection) {
-			this.#connection = new IpcClient(this.#agentDir, this.#connect, {
-				onOpen: async () => {
-					await this.#sync();
-					await this.#flushDeliveries();
-				},
-				onMessage: (message) => this.#receive(message),
-				onClose: (error) => {
-					this.#cancelRequests(error);
-					for (const id of this.#histories.keys()) this.#finishHistory(id);
-					this.#rejectSyncs(error);
-					this.#rejectStores(error);
-					if (this.#output && !this.#output.closed) this.#output.fail(error);
-					else this.#notify(error.message, "error");
-					this.#active = undefined;
-					this.#queue.length = 0;
-					this.#starting = false;
-					this.#status = "idle";
-				},
-			});
-			this.#connection.start();
-		} else {
-			void this.#sync().catch(() => {});
-		}
-	}
-
-	#description(): SessionDescription {
-		const context = this.#context;
-		if (!context) throw new Error("Chappie session is not available");
-		const name = this.#pi.getSessionName();
-		return {
-			id: context.sessionManager.getSessionId(),
-			cwd: context.cwd,
-			device: hostname(),
-			status: this.#status,
-			...(name ? { name } : {}),
-		};
-	}
-
-	async #sync(): Promise<void> {
-		const connection = this.#connection;
-		if (
-			!connection?.connected ||
-			!this.#context ||
-			this.#context.model?.provider !== "chappie"
-		)
-			return;
-		const id = this.#nextRequestId++;
-		const completion = Promise.withResolvers<void>();
-		this.#syncs.set(id, completion);
-		try {
-			await connection.send({ type: "sync", id, session: this.#description() });
-			await completion.promise;
-		} finally {
-			this.#syncs.delete(id);
-		}
-	}
-
-	async #receive(message: BrokerMessage): Promise<void> {
-		switch (message.type) {
-			case "response": {
-				const pending = this.#requests.get(message.id);
-				if (!pending) break;
-				if ("error" in message) pending.reject(new Error(message.error));
-				else {
-					const { type: _type, id: _id, ...result } = message;
-					pending.resolve(result);
-				}
-				break;
-			}
-			case "synced":
-				this.#syncs.get(message.id)?.resolve();
-				break;
-			case "stored":
-				this.#stores.get(message.id)?.resolve();
-				break;
-			case "notice":
-				if (
-					message.sessionId === this.#context?.sessionManager.getSessionId()
-				) {
-					this.#notify(message.message, "info", message.activity);
-				}
-				break;
-			case "inspect":
-				await this.#reply(message.id, message.sessionId, async () => {
-					const globalAgents = await this.#globalAgents();
-					return {
-						type: "result",
-						id: message.id,
-						inspection: this.#inspection(),
-						inputs: this.#inputs(),
-						...(globalAgents ? { globalAgents } : {}),
-					};
-				});
-				break;
-			case "history":
-				await this.#readHistory(message);
-				break;
-			case "ackInputs":
-				if (
-					message.sessionId === this.#context?.sessionManager.getSessionId()
-				) {
-					for (const id of message.ids) this.#pendingInputs.delete(id);
-				}
-				break;
-			case "readResource":
-				await this.#reply(message.id, message.sessionId, async () => ({
-					type: "result",
-					id: message.id,
-					resource: await readSessionResource(
-						message.sessionId,
-						message.uri,
-						message.offset,
-					),
-				}));
-				break;
-			case "copy": {
-				const controller = new AbortController();
-				this.#copies.set(message.id, controller);
-				void this.#reply(message.id, message.sessionId, async () => {
-					const context = this.#context;
-					if (!context) throw new Error("Chappie session is not available");
-					const files = await copyFiles(
-						message.paths,
-						message.resources,
-						context.cwd,
-						message.overwrite === true,
-						(resource) => this.#readChunks(resource, controller.signal),
-						controller.signal,
-					);
-					return {
-						type: "result",
-						id: message.id,
-						transfer: {
-							device: hostname(),
-							files,
-							resources: [],
-							to: { sessionId: message.sessionId, device: hostname() },
-						},
-					};
-				})
-					.finally(() => this.#copies.delete(message.id))
-					.catch(() => {});
-				break;
-			}
-			case "cancel": {
-				const copying = this.#copies.get(message.id);
-				if (copying) {
-					copying.abort(new Error(message.reason));
-					break;
-				}
-				if (this.#histories.has(message.id)) {
-					this.#finishHistory(message.id);
-					break;
-				}
-				const queued = this.#queue.findIndex(
-					(request) => request.id === message.id,
-				);
-				const request =
-					this.#queue[queued] ??
-					(this.#active?.request.id === message.id
-						? this.#active.request
-						: undefined);
-				if (!request) break;
-				const name =
-					request.type === "call"
-						? [...new Set(request.calls.map((call) => call.name))].join(", ")
-						: "chat";
-				this.#notify(
-					`${name} cancelled for ${chatLabel(request)}: ${message.reason}`,
-					"warning",
-					{
-						event: "cancelled",
-						...source(request.chatId, request.requestId),
-					},
-				);
-				if (queued !== -1) {
-					this.#queue.splice(queued, 1);
-					break;
-				}
-				const active = this.#active;
-				if (!active) break;
-				active.cancelled = message.reason;
-				if (active.completed) await this.#completeActive();
-				else this.#context?.abort();
-				break;
-			}
-			case "chat":
-			case "call":
-				if (
-					message.sessionId !== this.#context?.sessionManager.getSessionId()
-				) {
-					await this.#sendError(
-						message.id,
-						"The requested Pi session is no longer active",
-					);
-					break;
-				}
-				this.#queue.push(message);
-				this.#dispatch();
-				break;
-		}
-	}
-
-	async #request(
-		request: SessionRequest,
-		signal?: AbortSignal,
-	): Promise<SessionResult> {
-		signal?.throwIfAborted();
-		const connection = this.#connection;
-		if (!connection?.connected) throw new Error("Chappie is not connected");
-		const id = this.#nextRequestId++;
-		const completion = Promise.withResolvers<SessionResult>();
-		const onAbort = (): void => {
-			completion.reject(signal?.reason);
-			void connection.send({ type: "cancelRequest", id }).catch(() => {});
-		};
-		this.#requests.set(id, completion);
-		signal?.addEventListener("abort", onAbort, { once: true });
-		void connection
-			.send({ type: "request", id, request })
-			.catch(completion.reject);
-		try {
-			return await completion.promise;
-		} finally {
-			this.#requests.delete(id);
-			signal?.removeEventListener("abort", onAbort);
-		}
-	}
-
-	async *#readChunks(
-		resource: ResourceDescriptor,
-		signal: AbortSignal,
-	): AsyncGenerator<Uint8Array> {
-		for (let offset = 0; offset < resource.size; ) {
-			const result = await this.#request(
-				{
-					type: "readResource",
-					sessionId: resourceSessionId(resource.uri),
-					uri: resource.uri,
-					offset,
-				},
-				signal,
-			);
-			if (!("resource" in result))
-				throw new Error("Pi session returned no resource");
-			const data = Buffer.from(result.resource.blob, "base64");
-			if (data.length === 0)
-				throw new Error(
-					`Source ended before ${resource.size} bytes: ${resource.name}`,
-				);
-			yield data;
-			offset += data.length;
-		}
-	}
-
-	#cancelRequests(error: Error): void {
-		for (const pending of this.#requests.values()) pending.reject(error);
-		this.#requests.clear();
-		for (const controller of this.#copies.values()) controller.abort(error);
-		this.#copies.clear();
-	}
-
-	async #readHistory(
-		request: HistoryRequest["request"],
-		wait = request.range.wait,
-	): Promise<void> {
-		try {
-			const context = this.#context;
-			if (context?.sessionManager.getSessionId() !== request.sessionId)
-				throw new Error("The requested Pi session is no longer active");
-			const history = historyResult(
-				context.sessionManager.getBranch(),
-				request.sessionId,
-				request.range,
-			);
-			if (wait && !request.range.before && history.count === 0) {
-				if (!this.#histories.has(request.id)) {
-					this.#histories.set(request.id, {
-						request,
-						timeout: setTimeout(() => {
-							void this.#readHistory(request, false).catch(() => {});
-						}, 30_000),
-					});
-				}
-				return;
-			}
-			this.#finishHistory(request.id);
-			if (!request.range.observer) {
-				this.#notify(
-					`${chatLabel(request)} read history: ${history.count} entries`,
-					"info",
-					{ event: "history", ...source(request.chatId, request.requestId) },
-				);
-			}
-			await this.#connection?.send({
-				type: "result",
-				id: request.id,
-				cwd: context.cwd,
-				history,
-			});
-		} catch (error) {
-			this.#finishHistory(request.id);
-			await this.#sendError(
-				request.id,
-				error instanceof Error ? error.message : String(error),
-			);
-		}
-	}
-
-	#historyChanged(): void {
-		for (const { request } of this.#histories.values()) {
-			void this.#readHistory(request).catch(() => {});
-		}
-	}
-
-	#finishHistory(id: number): void {
-		const pending = this.#histories.get(id);
-		if (!pending) return;
-		clearTimeout(pending.timeout);
-		this.#histories.delete(id);
-	}
-
-	#inspection(): SessionInspection {
-		const activeTools = new Set(this.#pi.getActiveTools());
-		this.#collectInputs();
-		return {
-			session: this.#description(),
-			tools: this.#pi
-				.getAllTools()
-				.filter((tool) => activeTools.has(tool.name)),
-			skills: this.#pi
-				.getCommands()
-				.filter((command) => command.source === "skill"),
-		};
-	}
-
-	async #globalAgents(): Promise<{ path: string } | undefined> {
-		const path = resolve(this.#agentDir, "AGENTS.md");
-		try {
-			await access(path);
-			return { path };
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-			throw error;
-		}
-	}
-
-	#dispatch(): void {
-		if (this.#active) return;
-		const request = this.#queue[0];
-		if (!request) return;
-		const output = this.#output;
-		if (!output || output.closed) {
-			this.#wake();
-			return;
-		}
-
-		this.#queue.shift();
-		output.message.chappie = source(request.chatId, request.requestId);
-		this.#active = {
-			request,
-			session: this.#description(),
-			message: output.message,
-			completed: false,
-			cancelled: undefined,
-			toolResults: [],
-		};
-		this.#status = "executing";
-		void this.#sync().catch(() => {});
-		if (request.type === "chat") {
-			output.text(request.text);
-			output.done();
-		} else {
-			output.toolCalls(request.calls);
-			output.done("toolUse");
-		}
-	}
-
-	#wake(): void {
-		if (
-			this.#starting ||
-			this.#output ||
-			this.#active ||
-			this.#queue.length === 0 ||
-			!this.#context?.isIdle()
-		)
-			return;
-		this.#starting = true;
-		this.#pi.sendMessage(
-			{
-				customType: "chappie.request",
-				content: "",
-				display: false,
-			},
-			{ triggerTurn: true },
-		);
-	}
-
-	async #turnEnd(
-		message: unknown,
-		toolResults: ToolResultMessage[],
-		context: ExtensionContext,
-	): Promise<void> {
-		this.#context = context;
-		this.#historyChanged();
-		const active = this.#active;
-		if (!active || message !== active.message) return;
-		const sessionId = active.session.id;
-		for (const result of toolResults) rememberImages(sessionId, result.content);
-		active.completed = true;
-		active.toolResults = toolResults;
-	}
-
-	async #completeActive(): Promise<void> {
-		const active = this.#active;
-		if (!active?.completed) return;
-		this.#collectInputs();
-		const inputs = this.#inputs();
-		if (active.cancelled !== undefined) {
-			const delivery: DeliveryRecord = {
-				id: randomUUID(),
-				...source(active.request.chatId, active.request.requestId),
-				sessionId: active.session.id,
-				cwd: active.session.cwd,
-				toolResults: active.toolResults,
-				error: active.cancelled,
-			};
-			this.#deliveries.set(delivery.id, delivery);
-			void this.#flushDeliveries().catch(() => {});
-		} else {
-			await this.#connection?.send({
-				type: "result",
-				id: active.request.id,
-				cwd: active.session.cwd,
-				message: active.message,
-				inputs,
-				...(active.request.type === "call"
-					? { toolResults: active.toolResults }
-					: {}),
-			});
-		}
-		this.#active = undefined;
-		this.#status = "idle";
-		void this.#sync().catch(() => {});
-	}
-
-	#resetInputs(
-		context?: ExtensionContext,
-		cursor = context?.sessionManager.getLeafId() ?? null,
-	): void {
-		this.#sessionId = context?.sessionManager.getSessionId();
-		this.#inputCursor = cursor;
-		this.#pendingInputs.clear();
-	}
-
-	#collectInputs(): void {
-		const context = this.#context;
-		if (!context) return;
-		const sessionManager = context.sessionManager;
-		const sessionId = sessionManager.getSessionId();
-		if (this.#sessionId !== sessionId) {
-			this.#resetInputs(context);
-			return;
-		}
-		const leafId = sessionManager.getLeafId();
-		if (leafId === this.#inputCursor) return;
-		const entries: SessionEntry[] = [];
-		let current = sessionManager.getLeafEntry();
-		while (current && current.id !== this.#inputCursor) {
-			entries.push(current);
-			current = current.parentId
-				? sessionManager.getEntry(current.parentId)
-				: undefined;
-		}
-		if (this.#inputCursor !== null && !current) {
-			this.#resetInputs(context);
-			return;
-		}
-		for (const entry of entries.reverse()) {
-			if (entry.type !== "message" || entry.message.role !== "user") continue;
-			const message = entry.message as UserMessage;
-			if (typeof message.content !== "string") {
-				rememberImages(sessionId, message.content);
-			}
-			this.#pendingInputs.set(entry.id, { id: entry.id, sessionId, message });
-		}
-		this.#inputCursor = leafId;
-	}
-
-	#inputs(): SessionInput[] {
-		this.#collectInputs();
-		return [...this.#pendingInputs.values()];
-	}
-
-	async #flushDeliveries(): Promise<void> {
-		const flushed = this.#flushing.then(async () => {
-			const connection = this.#connection;
-			if (!connection?.connected) return;
-			for (const delivery of this.#deliveries.values()) {
-				const completion = Promise.withResolvers<void>();
-				this.#stores.set(delivery.id, completion);
-				try {
-					await connection.send({ type: "delivery", delivery });
-					await completion.promise;
-					this.#deliveries.delete(delivery.id);
-					this.#notify(
-						`Result saved for ChatGPT ${delivery.chatId.slice(-4)}`,
-						"info",
-						{
-							event: "result_saved",
-							...source(delivery.chatId, delivery.requestId),
-						},
-					);
-				} finally {
-					this.#stores.delete(delivery.id);
-				}
-			}
-		});
-		this.#flushing = flushed.catch(() => {});
-		return flushed;
-	}
-
-	async #reply(
-		id: number,
-		sessionId: string,
-		response: () =>
-			| Parameters<IpcClient["send"]>[0]
-			| Promise<Parameters<IpcClient["send"]>[0]>,
-	): Promise<void> {
-		try {
-			if (sessionId !== this.#context?.sessionManager.getSessionId()) {
-				throw new Error("The requested Pi session is no longer active");
-			}
-			await this.#connection?.send(await response());
-		} catch (error) {
-			await this.#sendError(
-				id,
-				error instanceof Error ? error.message : String(error),
-			);
-		}
-	}
-
-	async #sendError(id: number, error: string): Promise<void> {
-		await this.#connection?.send({ type: "result", id, error });
-	}
-
-	#rejectSyncs(error: Error): void {
-		for (const sync of this.#syncs.values()) sync.reject(error);
-		this.#syncs.clear();
-	}
-
-	#rejectStores(error: Error): void {
-		for (const store of this.#stores.values()) store.reject(error);
-		this.#stores.clear();
-	}
-}