@visorcraft/idlehands 4.0.7 → 4.0.8

package/dist/anton-RLNAl1Wi.js

@@ -1,579 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
-import { t as CONFIG_DIR } from "./utils-CXzXXV2o.js";
-import path from "node:path";
-import fsPromises from "node:fs/promises";
-
-//#region src/commands/anton.ts
-var anton_exports = /* @__PURE__ */ __exportAll({
-	antonStatus: () => antonStatus,
-	antonStop: () => antonStop,
-	formatProgressMessage: () => formatProgressMessage,
-	runAnton: () => runAnton
-});
-const ANTON_STATE_PATH = path.join(CONFIG_DIR, "anton.state.json");
-const ANTON_LOCK_PATH = path.join(CONFIG_DIR, "anton.lock");
-async function ensureStateDir() {
-	await fsPromises.mkdir(CONFIG_DIR, { recursive: true });
-}
-async function readState() {
-	try {
-		return JSON.parse(await fsPromises.readFile(ANTON_STATE_PATH, "utf8"));
-	} catch {
-		return { running: false };
-	}
-}
-async function writeState(state) {
-	await ensureStateDir();
-	await fsPromises.writeFile(ANTON_STATE_PATH, `${JSON.stringify({
-		...state,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}, null, 2)}\n`, "utf8");
-}
-async function acquireLock(force = false) {
-	await ensureStateDir();
-	try {
-		await fsPromises.writeFile(ANTON_LOCK_PATH, JSON.stringify({
-			pid: process.pid,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString()
-		}), {
-			encoding: "utf8",
-			flag: "wx"
-		});
-	} catch {
-		if (!force) throw new Error("Anton is already running (lock held)");
-		await fsPromises.rm(ANTON_LOCK_PATH, { force: true });
-		await fsPromises.writeFile(ANTON_LOCK_PATH, JSON.stringify({
-			pid: process.pid,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			force: true
-		}), {
-			encoding: "utf8",
-			flag: "wx"
-		});
-	}
-}
-async function releaseLock() {
-	await fsPromises.rm(ANTON_LOCK_PATH, { force: true });
-}
-async function shouldStop() {
-	const s = await readState();
-	return Boolean(s.stopRequested);
-}
-function parsePendingTasks(markdown) {
-	const lines = markdown.split(/\r?\n/);
-	const tasks = [];
-	for (let i = 0; i < lines.length; i++) {
-		const m = (lines[i] ?? "").match(/^(\s*)- \[ \] (.+)$/);
-		if (!m) continue;
-		tasks.push({
-			line: i + 1,
-			indent: m[1] ?? "",
-			text: (m[2] ?? "").trim()
-		});
-	}
-	return tasks;
-}
-function markTaskDone(markdown, lineNo) {
-	const lines = markdown.split(/\r?\n/);
-	const idx = lineNo - 1;
-	if (idx < 0 || idx >= lines.length) return markdown;
-	lines[idx] = (lines[idx] ?? "").replace(/^(\s*)- \[ \] /, "$1- [x] ");
-	return `${lines.join("\n")}\n`;
-}
-function buildDirectTaskPrompt(task) {
-	return [
-		"You are executing one item from a managed checklist.",
-		`Task: ${task}`,
-		"Rules:",
-		"1) Make the minimal code changes required for this task.",
-		"2) Run targeted tests for your change.",
-		"3) Return a concise completion summary."
-	].join("\n");
-}
-function buildDiscoveryPrompt(task, taskFile, planFilePath) {
-	return `You are running PRE-FLIGHT for an autonomous coding orchestrator.
-
-## RULES
-- DO NOT implement code changes. DO NOT modify source files.
-- You may ONLY write to the plan file specified below.
-- Read the codebase to understand what needs to change.
-
-## TASK
-From task file: ${taskFile}
-Task: ${task}
-
-## DECISION FLOW
-
-**If task is ALREADY COMPLETE** (you are CERTAIN it's done after checking with tools):
-→ Return ONLY: {"status":"complete","filename":""}
-
-**If task is INCOMPLETE or UNCERTAIN**:
-1. Read relevant source files to understand the current state
-2. Write a detailed implementation plan to: ${planFilePath}
-3. The plan MUST include:
-   - Task description (verbatim from above)
-   - What needs to change and why
-   - Implementation approach with specific steps
-   - Files to modify/create
-   - How to verify (test commands)
-4. Verify the file exists and is non-empty
-5. Return ONLY: {"status":"incomplete","filename":"${planFilePath}"}
-
-## OUTPUT
-Return ONLY the JSON object. No markdown fences. No explanation.`;
-}
-function buildReviewPrompt(planFilePath) {
-	return `Review this implementation plan and improve it:
-${planFilePath}
-
-Treat it as written by a junior developer. Look for:
-- Missing edge cases
-- Opportunities to reuse existing code
-- Unclear or ambiguous steps
-- Missing test scenarios
-
-Update the SAME file in-place with your improvements.
-
-After review, return ONLY:
-{"status":"ready","filename":"${planFilePath}"}
-
-Do not return status=ready unless the file exists and has content.
-Return JSON only. No markdown fences. No commentary.`;
-}
-function buildImplementationPrompt(task, planFilePath) {
-	return [
-		"You are implementing a task from a managed checklist.",
-		"A planning agent has already analyzed the codebase and written a detailed spec.",
-		"",
-		`Task: ${task}`,
-		"",
-		`Implementation plan: ${planFilePath}`,
-		"",
-		"Rules:",
-		"1) Read the plan file FIRST — it contains the implementation approach.",
-		"2) Follow the plan precisely. Make the code changes specified.",
-		"3) Run the verification steps from the plan.",
-		"4) Return a concise completion summary.",
-		"",
-		"Do not deviate from the plan unless you find a clear error in it."
-	].join("\n");
-}
-function formatDuration(ms) {
-	const seconds = Math.floor(ms / 1e3);
-	if (seconds < 60) return `${seconds}s`;
-	const minutes = Math.floor(seconds / 60);
-	const secs = seconds % 60;
-	if (minutes < 60) return `${minutes}m ${secs}s`;
-	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
-}
-function formatProgressMessage(event) {
-	switch (event.phase) {
-		case "start": return `🤚 **Anton activated**\n📄 Task file: \`${path.basename(event.taskFile)}\`\n📋 ${event.totalTasks} task${event.totalTasks === 1 ? "" : "s"} pending`;
-		case "task_start": return `\n🔪 **Task ${event.index}/${event.total}**: ${event.task}`;
-		case "discovery_start": return `🔎 Discovery: analyzing codebase for task ${event.index}/${event.total}...`;
-		case "discovery_complete": return `📝 Plan written: \`${path.basename(event.planFile)}\``;
-		case "discovery_failed": return `⚠️ Discovery failed: ${event.error}\n└ Falling back to direct execution`;
-		case "discovery_already_complete": return `✅ Discovery says task already complete — skipping implementation`;
-		case "review_start": return `🧪 Reviewing plan: \`${path.basename(event.planFile)}\`...`;
-		case "review_complete": return `✅ Plan reviewed and refined`;
-		case "review_failed": return `⚠️ Review failed: ${event.error}\n└ Proceeding with unreviewed plan`;
-		case "implementation_start": return event.planFile ? `🛠️ Implementation: following spec \`${path.basename(event.planFile)}\`` : `🛠️ Implementation: direct execution`;
-		case "task_agent_spawned": return `🤖 Agent spawned (session: \`${event.sessionId}\`)`;
-		case "task_complete": return `✅ **Task ${event.index}/${event.total} complete**: ${event.task}`;
-		case "task_failed": return `❌ **Task ${event.index}/${event.total} failed**: ${event.task}\n└ ${event.error}`;
-		case "task_skipped": return `⏭️ **Task ${event.index}/${event.total} skipped**: ${event.task}\n└ ${event.reason}`;
-		case "stopped": return `🛑 **Anton stopped** (${event.completedSoFar}/${event.total} completed before stop)`;
-		case "finish": return [
-			`\n🏁 **Anton finished**`,
-			`✅ Completed: ${event.completed}/${event.total}`,
-			event.skipped > 0 ? `⏭️ Skipped: ${event.skipped}` : null,
-			`⏱️ Duration: ${formatDuration(event.durationMs)}`
-		].filter(Boolean).join("\n");
-	}
-}
-async function antonStatus(runtime) {
-	const s = await readState();
-	if (!s.running) {
-		runtime.log("Anton is idle.");
-		if (s.lastSummary) runtime.log(s.lastSummary);
-		return;
-	}
-	runtime.log(`Anton running: ${s.completed ?? 0}/${s.total ?? 0} complete` + (s.taskFile ? ` | file=${s.taskFile}` : "") + (typeof s.currentIndex === "number" ? ` | current=${s.currentIndex + 1}` : ""));
-}
-async function antonStop(runtime) {
-	const s = await readState();
-	if (!s.running) {
-		runtime.log("Anton is not running.");
-		return;
-	}
-	await writeState({
-		...s,
-		stopRequested: true
-	});
-	runtime.log("Anton stop requested. It will stop after current task.");
-}
-/** Load Anton config from the IdleHands config file. */
-async function loadAntonConfig() {
-	try {
-		const { loadConfig } = await import("./model-selection-CSn9tUuH.js").then((n) => n.Mt);
-		return loadConfig().anton ?? {};
-	} catch {
-		return {};
-	}
-}
-async function runAgentTask(args) {
-	const { agentCliCommand } = await import("./agent-via-gateway-DpOnWB8B.js").then((n) => n.n);
-	const extraSystemPrompt = args.workspaceDir ? `Your working directory is: ${args.workspaceDir}\nAll file paths are relative to this directory. Use this as your cwd for all operations.` : void 0;
-	await agentCliCommand({
-		message: args.message,
-		agent: args.agent,
-		to: args.to,
-		sessionId: args.sessionId,
-		timeout: args.timeout,
-		json: false,
-		deliver: false,
-		extraSystemPrompt
-	}, args.runtime, args.deps);
-}
-function makePlanFilePath(planDir, taskIndex) {
-	return path.join(planDir, `task-${taskIndex}-${Date.now()}.md`);
-}
-async function ensurePlanDir(planDir) {
-	await fsPromises.mkdir(planDir, { recursive: true });
-}
-async function isPlanFileValid(filePath) {
-	try {
-		const stat = await fsPromises.stat(filePath);
-		return stat.isFile() && stat.size > 10;
-	} catch {
-		return false;
-	}
-}
-async function runDiscoveryPhase(args) {
-	const planFile = makePlanFilePath(args.planDir, args.taskNum);
-	await ensurePlanDir(args.planDir);
-	await args.notify({
-		phase: "discovery_start",
-		index: args.taskNum,
-		total: args.total,
-		task: args.task.text
-	});
-	for (let attempt = 0; attempt <= args.maxRetries; attempt++) {
-		const sessionId = `anton-discovery-${Date.now()}-${args.taskNum}-${attempt}`;
-		try {
-			await args.notify({
-				phase: "task_agent_spawned",
-				index: args.taskNum,
-				total: args.total,
-				task: `Discovery (attempt ${attempt + 1})`,
-				sessionId
-			});
-			await runAgentTask({
-				message: buildDiscoveryPrompt(args.task.text, args.taskFile, planFile),
-				sessionId,
-				timeout: args.timeout,
-				agent: args.agent,
-				to: args.to,
-				runtime: args.runtime,
-				deps: args.deps,
-				workspaceDir: args.workspaceDir
-			});
-			if (await isPlanFileValid(planFile)) {
-				await args.notify({
-					phase: "discovery_complete",
-					index: args.taskNum,
-					total: args.total,
-					task: args.task.text,
-					planFile
-				});
-				return {
-					status: "plan_ready",
-					planFile
-				};
-			}
-			if (attempt === args.maxRetries) return {
-				status: "failed",
-				error: "Discovery did not produce a valid plan file"
-			};
-		} catch (err) {
-			const errorMsg = err instanceof Error ? err.message : String(err);
-			if (attempt === args.maxRetries) {
-				await args.notify({
-					phase: "discovery_failed",
-					index: args.taskNum,
-					total: args.total,
-					task: args.task.text,
-					error: errorMsg
-				});
-				return {
-					status: "failed",
-					error: errorMsg
-				};
-			}
-		}
-	}
-	return {
-		status: "failed",
-		error: "Discovery exhausted retries"
-	};
-}
-async function runReviewPhase(args) {
-	await args.notify({
-		phase: "review_start",
-		index: args.taskNum,
-		total: args.total,
-		task: args.task.text,
-		planFile: args.planFile
-	});
-	const sessionId = `anton-review-${Date.now()}-${args.taskNum}`;
-	try {
-		await args.notify({
-			phase: "task_agent_spawned",
-			index: args.taskNum,
-			total: args.total,
-			task: "Requirements review",
-			sessionId
-		});
-		await runAgentTask({
-			message: buildReviewPrompt(args.planFile),
-			sessionId,
-			timeout: args.timeout,
-			agent: args.agent,
-			to: args.to,
-			runtime: args.runtime,
-			deps: args.deps,
-			workspaceDir: args.workspaceDir
-		});
-		await args.notify({
-			phase: "review_complete",
-			index: args.taskNum,
-			total: args.total,
-			task: args.task.text,
-			planFile: args.planFile
-		});
-		return { success: true };
-	} catch (err) {
-		const errorMsg = err instanceof Error ? err.message : String(err);
-		await args.notify({
-			phase: "review_failed",
-			index: args.taskNum,
-			total: args.total,
-			task: args.task.text,
-			error: errorMsg
-		});
-		return {
-			success: false,
-			error: errorMsg
-		};
-	}
-}
-async function runAnton(args) {
-	const filePath = path.resolve(args.taskFile);
-	const pending = parsePendingTasks(await fsPromises.readFile(filePath, "utf8"));
-	const notify = args.onProgress ?? (async () => {});
-	if (args.dryRun) {
-		args.runtime.log(`Dry run: ${pending.length} pending task(s)`);
-		for (const t of pending) args.runtime.log(`- [ ] ${t.text}`);
-		return;
-	}
-	if (pending.length === 0) {
-		args.runtime.log("No pending tasks.");
-		await notify({
-			phase: "finish",
-			completed: 0,
-			skipped: 0,
-			total: 0,
-			durationMs: 0
-		});
-		return;
-	}
-	const antonCfg = await loadAntonConfig();
-	const mode = args.mode ?? antonCfg.mode ?? "direct";
-	const requirementsReview = antonCfg.requirementsReview ?? false;
-	const taskTimeout = antonCfg.taskTimeoutSec ?? 1200;
-	const discoveryTimeout = antonCfg.discoveryTimeoutSec ?? taskTimeout;
-	const reviewTimeout = antonCfg.reviewTimeoutSec ?? taskTimeout;
-	const preflightMaxRetries = antonCfg.preflightMaxRetries ?? 2;
-	const planDir = antonCfg.planDir ? path.resolve(antonCfg.planDir) : path.resolve(path.dirname(filePath), ".agents", "tasks");
-	const { loadConfig } = await import("./model-selection-CSn9tUuH.js").then((n) => n.Mt);
-	const cfg = loadConfig();
-	const defaultTimeout = String(Number.isFinite(args.timeoutSec) && (args.timeoutSec ?? 0) > 0 ? args.timeoutSec : cfg.agents?.defaults?.timeoutSeconds ?? taskTimeout);
-	await acquireLock(Boolean(args.force));
-	const startedAt = Date.now();
-	await writeState({
-		running: true,
-		taskFile: filePath,
-		startedAt: new Date(startedAt).toISOString(),
-		currentIndex: 0,
-		total: pending.length,
-		completed: 0,
-		skipped: 0,
-		stopRequested: false
-	});
-	await notify({
-		phase: "start",
-		taskFile: filePath,
-		totalTasks: pending.length
-	});
-	args.runtime.log(`[Anton] Mode: ${mode}${mode === "preflight" ? requirementsReview ? " (with review)" : " (discovery → implementation)" : ""}`);
-	let completed = 0;
-	let skipped = 0;
-	try {
-		for (let i = 0; i < pending.length; i++) {
-			if (await shouldStop()) {
-				args.runtime.log("Anton stop acknowledged.");
-				await notify({
-					phase: "stopped",
-					completedSoFar: completed,
-					total: pending.length
-				});
-				break;
-			}
-			const task = pending[i];
-			if (!task) continue;
-			const taskNum = i + 1;
-			await writeState({
-				running: true,
-				taskFile: filePath,
-				startedAt: new Date(startedAt).toISOString(),
-				currentIndex: i,
-				total: pending.length,
-				completed,
-				skipped,
-				stopRequested: false
-			});
-			args.runtime.log(`\n[Anton] Task ${taskNum}/${pending.length}: ${task.text}`);
-			await notify({
-				phase: "task_start",
-				index: taskNum,
-				total: pending.length,
-				task: task.text
-			});
-			try {
-				let planFile;
-				if (mode === "preflight") {
-					const discoveryResult = await runDiscoveryPhase({
-						task,
-						taskNum,
-						total: pending.length,
-						taskFile: filePath,
-						planDir,
-						timeout: String(discoveryTimeout),
-						maxRetries: preflightMaxRetries,
-						agent: args.agent,
-						to: args.to,
-						runtime: args.runtime,
-						deps: args.deps,
-						notify,
-						workspaceDir: args.workspaceDir
-					});
-					if (discoveryResult.status === "complete") {
-						await notify({
-							phase: "discovery_already_complete",
-							index: taskNum,
-							total: pending.length,
-							task: task.text
-						});
-						const updated = markTaskDone(await fsPromises.readFile(filePath, "utf8"), task.line);
-						await fsPromises.writeFile(filePath, updated, "utf8");
-						completed += 1;
-						await notify({
-							phase: "task_complete",
-							index: taskNum,
-							total: pending.length,
-							task: task.text
-						});
-						continue;
-					}
-					if (discoveryResult.status === "plan_ready" && discoveryResult.planFile) {
-						planFile = discoveryResult.planFile;
-						if (requirementsReview) await runReviewPhase({
-							task,
-							taskNum,
-							total: pending.length,
-							planFile,
-							timeout: String(reviewTimeout),
-							agent: args.agent,
-							to: args.to,
-							runtime: args.runtime,
-							deps: args.deps,
-							notify,
-							workspaceDir: args.workspaceDir
-						});
-					}
-				}
-				await notify({
-					phase: "implementation_start",
-					index: taskNum,
-					total: pending.length,
-					task: task.text,
-					planFile
-				});
-				const implSessionId = `anton-impl-${Date.now()}-${taskNum}`;
-				await notify({
-					phase: "task_agent_spawned",
-					index: taskNum,
-					total: pending.length,
-					task: task.text,
-					sessionId: implSessionId
-				});
-				await runAgentTask({
-					message: planFile ? buildImplementationPrompt(task.text, planFile) : buildDirectTaskPrompt(task.text),
-					sessionId: implSessionId,
-					timeout: defaultTimeout,
-					agent: args.agent,
-					to: args.to,
-					runtime: args.runtime,
-					deps: args.deps,
-					workspaceDir: args.workspaceDir
-				});
-				const updated = markTaskDone(await fsPromises.readFile(filePath, "utf8"), task.line);
-				await fsPromises.writeFile(filePath, updated, "utf8");
-				completed += 1;
-				await notify({
-					phase: "task_complete",
-					index: taskNum,
-					total: pending.length,
-					task: task.text
-				});
-			} catch (err) {
-				skipped += 1;
-				const errorMsg = err instanceof Error ? err.message : String(err);
-				args.runtime.error(`[Anton] Task failed and was skipped: ${task.text}`);
-				args.runtime.error(errorMsg);
-				await notify({
-					phase: "task_failed",
-					index: taskNum,
-					total: pending.length,
-					task: task.text,
-					error: errorMsg
-				});
-			}
-		}
-		const durationMs = Date.now() - startedAt;
-		const summary = `Anton finished: completed=${completed}, skipped=${skipped}, total=${pending.length}, duration=${formatDuration(durationMs)}`;
-		await writeState({
-			running: false,
-			taskFile: filePath,
-			startedAt: new Date(startedAt).toISOString(),
-			total: pending.length,
-			completed,
-			skipped,
-			lastSummary: summary,
-			stopRequested: false
-		});
-		args.runtime.log(`\n${summary}`);
-		await notify({
-			phase: "finish",
-			completed,
-			skipped,
-			total: pending.length,
-			durationMs
-		});
-	} finally {
-		await releaseLock();
-	}
-}
-
-//#endregion
-export { runAnton as i, antonStop as n, anton_exports as r, antonStatus as t };

package/dist/plugin-sdk/web-CWWIv9mK.js

@@ -1,71 +0,0 @@
-import "./accounts-Kt6ygPsC.js";
-import "./reply-BKLT5LXW.js";
-import "./paths-CtGV5i8O.js";
-import "./github-copilot-token-CY2euW0d.js";
-import "./config-BzPMtEKA.js";
-import "./utils-dP-FpIgu.js";
-import "./subsystem-lJo9gqAK.js";
-import "./runtime-CjfcfOBD.js";
-import "./env-qurSiOO2.js";
-import "./agent-scope-CU41EMlR.js";
-import "./dock-CMURqoee.js";
-import "./message-channel-DiMXmQeQ.js";
-import "./sessions-CQ5iD4Uq.js";
-import "./plugins-DRPlVBr_.js";
-import "./accounts-B9nfRzyn.js";
-import "./accounts-mjFAny5F.js";
-import "./bindings-BDKKHGv-.js";
-import { i as logWebSelfId, p as webAuthExists, s as pickWebChannel, t as WA_WEB_AUTH_DIR } from "./auth-store-DycBvVqL.js";
-import "./send-BBD-m-nM.js";
-import "./paths-CSpzSLh8.js";
-import "./fetch-Bdjb7Pke.js";
-import "./retry-2OVzZJMZ.js";
-import "./redact-Ub8sMBBC.js";
-import "./errors-UqLewZJL.js";
-import "./channel-activity-TcS_VfJk.js";
-import "./path-alias-guards-yyy61qHh.js";
-import "./fs-safe-CCXTOK7j.js";
-import "./image-ops-BRYGGDwL.js";
-import "./ssrf-C3kIyB5u.js";
-import "./fetch-guard-C174s8ZV.js";
-import "./local-roots-bHCsSVt_.js";
-import "./ir-Bv0Zbp2E.js";
-import "./chunk-DZr5xuqv.js";
-import "./markdown-tables-DfUQHRZY.js";
-import "./render-latcSJiL.js";
-import "./tables-C4X_nAUQ.js";
-import "./send-SsqudCMv.js";
-import "./send-CPeuqOlq.js";
-import "./tool-images-Cf9aWlVu.js";
-import "./target-errors-CXh6e9ZE.js";
-import "./send-A4Lv5nrg.js";
-import "./runner-Ck0w3rcz.js";
-import "./reply-prefix-BqV0o7_7.js";
-import "./tokens-CU9S3S7t.js";
-import "./skill-commands-C_O9I71g.js";
-import "./skills-DmiIiX4l.js";
-import "./chrome-BCTizrZD.js";
-import "./deliver-Cfc1UCre.js";
-import "./diagnostic-B8VzcqLf.js";
-import "./store-BI3rLJdW.js";
-import "./pi-embedded-helpers-BAm9cWol.js";
-import { n as monitorWebInbox, t as monitorWebChannel } from "./channel-web-DFBbK8o7.js";
-import "./thinking-g4Rrlwu4.js";
-import "./image-DDuK8tyO.js";
-import "./pi-model-discovery-Bt6JtUFr.js";
-import "./api-key-rotation-CZhCWd61.js";
-import "./commands-registry-BqJLwZYh.js";
-import "./diagnostic-session-state-Br7SziNV.js";
-import "./manager-CTC1S_c9.js";
-import "./query-expansion-CPqK-tTR.js";
-import "./send-CaPoBwby.js";
-import "./proxy-C4ewPdlN.js";
-import "./resolve-route-C5mAwY-o.js";
-import "./replies-DwTNZJgi.js";
-import "./deps-C2JklbCf.js";
-import "./outbound-attachment-Bs7fNaqv.js";
-import { n as sendMessageWhatsApp } from "./outbound-B1twcfz5.js";
-import { i as waitForWaConnection, t as createWaSocket } from "./session-DpL4uk1J.js";
-import { t as loginWeb } from "./login-CkQrnY2G.js";
-
-export { WA_WEB_AUTH_DIR, createWaSocket, logWebSelfId, loginWeb, monitorWebChannel, monitorWebInbox, pickWebChannel, sendMessageWhatsApp, waitForWaConnection, webAuthExists };