@dex-ai/web-tools 0.1.1

package/README.md

@@ -0,0 +1,49 @@
+# @dex-ai/web-tools
+
+Web fetch and search tools for Dex agents.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `web_fetch` | Fetch any URL and return its content as clean markdown/text/JSON. Uses Readability + turndown for HTML→markdown. |
+| `web_search` | Search the web. Default: DuckDuckGo HTML search (no API key). Configurable backend. |
+| `web_snapshot` | *(optional)* Render a page with Playwright headless browser for JS-rendered content. |
+
+## Usage
+
+```typescript
+import { createWebToolsExtension } from "@dex-ai/web-tools";
+
+const agent = await Agent.create({
+  extensions: [
+    createWebToolsExtension({
+      // optional config
+      timeout: 15_000,
+      cacheTTL: 300_000,
+      rateLimitPerDomain: 10,
+    }),
+    // ... other extensions
+  ],
+});
+```
+
+## Configuration
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `timeout` | `15_000` | Request timeout in ms |
+| `maxResponseSize` | `1_048_576` | Max response body (bytes) |
+| `cacheTTL` | `300_000` | Cache TTL in ms (5 min) |
+| `rateLimitPerDomain` | `10` | Max requests per domain per window |
+| `rateLimitWindow` | `60_000` | Rate limit window in ms |
+| `searchEndpoint` | DuckDuckGo | Custom search URL |
+| `searchApiKey` | — | API key for custom search |
+| `allowedDomains` | `[]` | Allowlist (empty = all allowed) |
+| `blockedDomains` | `[]` | Blocklist |
+| `respectRobotsTxt` | `true` | Check robots.txt before fetching |
+
+## Sub-path Exports
+
+- `@dex-ai/web-tools` — core: `web_fetch` + `web_search`
+- `@dex-ai/web-tools/with-snapshot` — adds `web_snapshot` (requires Playwright install)

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dex-ai/web-tools",
+  "version": "0.1.1",
+  "description": "Web fetch and search tools for Dex agents — fetch URLs as clean markdown, search the web, and render JS pages with Playwright.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./with-snapshot": {
+      "types": "./src/with-snapshot.ts",
+      "default": "./src/with-snapshot.ts"
+    }
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "changeset publish"
+  },
+  "dependencies": {
+    "@dex-ai/sdk": "^0.1.2",
+    "zod": "^3.23.8",
+    "jsdom": "^25.0.0",
+    "@mozilla/readability": "^0.5.0",
+    "turndown": "^7.2.0"
+  },
+  "optionalDependencies": {
+    "playwright": "^1.48.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "@types/bun": "latest",
+    "bun-types": "latest",
+    "@types/jsdom": "^21.1.7",
+    "@types/turndown": "^5.0.5",
+    "@changesets/cli": "^2.29.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/src/cache.ts

@@ -0,0 +1,55 @@
+/**
+ * WebCache — disk-based request cache with TTL.
+ *
+ * Caches FetchResult objects keyed by SHA-256 hash of the URL.
+ * Handles malformed cache files gracefully by treating them as misses.
+ */
+
+import { createHash } from "node:crypto";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { FetchResult } from "./types";
+
+interface CacheEntry {
+	cachedAt: number;
+	result: FetchResult;
+}
+
+export class WebCache {
+	private dir: string;
+	private ttl: number;
+
+	constructor(dir: string, ttl: number) {
+		this.dir = dir;
+		this.ttl = ttl;
+	}
+
+	private key(url: string): string {
+		return createHash("sha256").update(url).digest("hex").slice(0, 16);
+	}
+
+	private path(url: string): string {
+		return join(this.dir, `${this.key(url)}.json`);
+	}
+
+	/** Retrieve a cached result. Returns null on miss or expiry. */
+	async get(url: string): Promise<FetchResult | null> {
+		try {
+			const raw = await readFile(this.path(url), "utf-8");
+			const entry = JSON.parse(raw) as CacheEntry;
+			if (Date.now() - entry.cachedAt > this.ttl) {
+				return null;
+			}
+			return entry.result;
+		} catch {
+			return null;
+		}
+	}
+
+	/** Store a result in the cache. */
+	async set(url: string, result: FetchResult): Promise<void> {
+		await mkdir(this.dir, { recursive: true });
+		const entry: CacheEntry = { cachedAt: Date.now(), result };
+		await writeFile(this.path(url), JSON.stringify(entry), "utf-8");
+	}
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+/**
+ * @dex-ai/web-tools — Web fetch and search tools for Dex agents.
+ *
+ * Provides:
+ *  - web_fetch: fetch URLs as clean markdown/text/JSON
+ *  - web_search: search the web via configurable backend (default: DuckDuckGo)
+ *
+ * Optional (sub-path @dex-ai/web-tools/with-snapshot):
+ *  - web_snapshot: render JS-rendered pages with Playwright
+ */
+
+import type { Extension, AnyTool } from "@dex-ai/sdk";
+import type { WebToolsConfig } from "./types";
+import { DEFAULTS } from "./types";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createWebFetchTool } from "./web-fetch";
+import { createWebSearchTool } from "./web-search";
+
+export type { WebToolsConfig, FetchResult, SearchResult } from "./types";
+
+/**
+ * Create the web tools extension with fetch and search capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createWebToolsExtension } from "@dex-ai/web-tools";
+ *
+ * const agent = await Agent.create({
+ *   extensions: [
+ *     createWebToolsExtension({ timeout: 10_000 }),
+ *   ],
+ * });
+ * ```
+ */
+export function createWebToolsExtension(
+	config: WebToolsConfig = {},
+): Extension {
+	// Resolve cache directory
+	const resolvedConfig: WebToolsConfig = {
+		...config,
+		cacheDir: config.cacheDir ?? join(homedir(), ".dex", "cache", "web"),
+		cacheTTL: config.cacheTTL ?? DEFAULTS.cacheTTL,
+		timeout: config.timeout ?? DEFAULTS.timeout,
+		maxResponseSize: config.maxResponseSize ?? DEFAULTS.maxResponseSize,
+		rateLimitPerDomain:
+			config.rateLimitPerDomain ?? DEFAULTS.rateLimitPerDomain,
+		rateLimitWindow: config.rateLimitWindow ?? DEFAULTS.rateLimitWindow,
+		userAgent: config.userAgent ?? DEFAULTS.userAgent,
+		respectRobotsTxt: config.respectRobotsTxt ?? DEFAULTS.respectRobotsTxt,
+	};
+
+	const tools: AnyTool[] = [
+		createWebFetchTool(resolvedConfig),
+		createWebSearchTool(resolvedConfig),
+	];
+
+	return {
+		name: "web-tools",
+		description: "Web fetch and search tools for Dex agents.",
+		tools,
+	};
+}

package/src/render.ts

@@ -0,0 +1,95 @@
+/**
+ * HTML→Markdown rendering utilities.
+ *
+ * - htmlToMarkdown: extract article content via Readability + convert to markdown via turndown
+ * - extractBySelector: extract text from a specific CSS selector
+ * - extractSearchResults: parse DuckDuckGo HTML search result page
+ */
+
+import { JSDOM } from "jsdom";
+import { Readability } from "@mozilla/readability";
+import TurndownService from "turndown";
+import type { SearchResult } from "./types";
+
+/* ── Turndown singleton ──────────────────────────────────── */
+
+let _turndown: TurndownService | null = null;
+
+function getTurndown(): TurndownService {
+	if (!_turndown) {
+		_turndown = new TurndownService({
+			headingStyle: "atx",
+			codeBlockStyle: "fenced",
+			linkStyle: "inlined",
+			bulletListMarker: "-",
+		});
+	}
+	return _turndown;
+}
+
+/* ── Public API ─────────────────────────────────────────── */
+
+/**
+ * Extract readable article content from HTML and convert to Markdown.
+ * Falls back to raw HTML→markdown if Readability fails to parse.
+ */
+export function htmlToMarkdown(
+	html: string,
+	url: string,
+): { title: string | null; content: string } {
+	const dom = new JSDOM(html, { url });
+	const reader = new Readability(dom.window.document);
+	const article = reader.parse();
+
+	const turndown = getTurndown();
+	const title = article?.title ?? null;
+	const body = article?.content ?? html;
+	const content = turndown.turndown(body);
+
+	return { title, content };
+}
+
+/**
+ * Extract text content from a specific CSS selector.
+ * Returns the text of the first matching element, or null.
+ */
+export function extractBySelector(
+	html: string,
+	selector: string,
+): string | null {
+	const dom = new JSDOM(html);
+	const el = dom.window.document.querySelector(selector);
+	if (!el) return null;
+	return el.textContent?.trim() ?? null;
+}
+
+/**
+ * Parse DuckDuckGo HTML search results page.
+ * Extracts title, URL, and snippet for each .result element.
+ */
+export function extractSearchResults(html: string): SearchResult[] {
+	const dom = new JSDOM(html);
+	const doc = dom.window.document;
+	const results: SearchResult[] = [];
+
+	const items = doc.querySelectorAll(".result");
+	for (const item of items) {
+		const linkEl = item.querySelector(".result__a");
+		const snippetEl = item.querySelector(".result__snippet");
+
+		if (!linkEl) continue;
+
+		const title = linkEl.textContent?.trim() ?? "";
+		const href = linkEl.getAttribute("href");
+		const snippet = snippetEl?.textContent?.trim() ?? "";
+
+		// DuckDuckGo wraps real URLs in redirect links — extract via text
+		const url = href ?? "";
+
+		if (title && url) {
+			results.push({ title, url, snippet });
+		}
+	}
+
+	return results;
+}

package/src/types.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared types for @dex-ai/web-tools.
+ */
+
+export interface WebToolsConfig {
+	/** User-Agent header for all requests */
+	userAgent?: string;
+	/** Default timeout in ms */
+	timeout?: number;
+	/** Max response body size in bytes */
+	maxResponseSize?: number;
+	/** Cache TTL in ms */
+	cacheTTL?: number;
+	/** Cache directory */
+	cacheDir?: string;
+	/** Rate limit: requests per domain per window */
+	rateLimitPerDomain?: number;
+	/** Rate limit window in ms */
+	rateLimitWindow?: number;
+	/** Custom search endpoint URL. If not set, uses DuckDuckGo. */
+	searchEndpoint?: string;
+	/** Custom search API key (if endpoint requires one). */
+	searchApiKey?: string;
+	/** Allowed domains (empty = all allowed). */
+	allowedDomains?: string[];
+	/** Blocked domains. */
+	blockedDomains?: string[];
+	/** Respect robots.txt before fetching. */
+	respectRobotsTxt?: boolean;
+}
+
+export interface FetchResult {
+	url: string;
+	title: string | null;
+	content: string;
+	format: "markdown" | "json" | "text";
+	excerpt: string | null;
+	size: number;
+	cached: boolean;
+	truncated: boolean;
+}
+
+export interface SearchResult {
+	title: string;
+	url: string;
+	snippet: string;
+}
+
+export interface SearchOptions {
+	count?: number;
+	site?: string;
+}
+
+export const DEFAULTS = {
+	userAgent: "Dex/1.0 WebTools",
+	timeout: 15_000,
+	maxResponseSize: 1_048_576,
+	cacheTTL: 300_000,
+	cacheDir: "", // resolved at runtime: ~/.dex/cache/web
+	rateLimitPerDomain: 10,
+	rateLimitWindow: 60_000,
+	respectRobotsTxt: true,
+} as const;

package/src/web-fetch.ts

@@ -0,0 +1,276 @@
+/**
+ * web_fetch tool — fetch a URL and return its content as clean markdown/text/JSON.
+ *
+ * Features:
+ *  - HTML→markdown via Readability + turndown
+ *  - JSON pretty-print passthrough
+ *  - CSS selector extraction
+ *  - Disk caching with TTL
+ *  - Rate limiting per domain
+ *  - SSRF protection (blocks private IPs)
+ *  - Response size cap
+ */
+
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { Tool } from "@dex-ai/sdk";
+import { WebCache } from "./cache";
+import { htmlToMarkdown, extractBySelector } from "./render";
+import type { WebToolsConfig, FetchResult } from "./types";
+import { DEFAULTS } from "./types";
+
+/* ── Rate limiting ──────────────────────────────────────── */
+
+const domainCounters = new Map<string, { count: number; resetAt: number }>();
+
+function checkRateLimit(
+	domain: string,
+	maxPerDomain: number,
+	window: number,
+): boolean {
+	const now = Date.now();
+	let entry = domainCounters.get(domain);
+	if (!entry || now > entry.resetAt) {
+		entry = { count: 0, resetAt: now + window };
+		domainCounters.set(domain, entry);
+	}
+	entry.count++;
+	return entry.count <= maxPerDomain;
+}
+
+/* ── SSRF protection ───────────────────────────────────── */
+
+function isPrivateHost(hostname: string): boolean {
+	const parts = hostname.toLowerCase();
+	return (
+		parts === "localhost" ||
+		parts === "127.0.0.1" ||
+		parts === "::1" ||
+		parts.startsWith("10.") ||
+		parts.startsWith("172.") ||
+		parts.startsWith("192.168.") ||
+		parts.endsWith(".local") ||
+		parts.endsWith(".localhost")
+	);
+}
+
+/* ── Tool factory ───────────────────────────────────────── */
+
+export function createWebFetchTool(
+	config: WebToolsConfig,
+): ReturnType<typeof Tool.define> {
+	const timeout = config.timeout ?? DEFAULTS.timeout;
+	const maxSize = config.maxResponseSize ?? DEFAULTS.maxResponseSize;
+	const cacheDir = config.cacheDir ?? join(homedir(), ".dex", "cache", "web");
+	const cacheTTL = config.cacheTTL ?? DEFAULTS.cacheTTL;
+	const cache = new WebCache(cacheDir, cacheTTL);
+	const rateLimitPerDomain =
+		config.rateLimitPerDomain ?? DEFAULTS.rateLimitPerDomain;
+	const rateLimitWindow = config.rateLimitWindow ?? DEFAULTS.rateLimitWindow;
+	const userAgent = config.userAgent ?? DEFAULTS.userAgent;
+	const allowedDomains = config.allowedDomains ?? [];
+	const blockedDomains = config.blockedDomains ?? [];
+
+	return Tool.define({
+		name: "web_fetch",
+		displayName: "Fetch",
+		description:
+			"Fetch a URL and return its content as clean markdown/text/JSON. " +
+			"Use for reading docs, web pages, APIs, and JSON endpoints. " +
+			"Large pages are auto-indexed into the session knowledge base for later search.",
+		access: "read" as const,
+		parameters: z.object({
+			url: z.string().url().describe("The URL to fetch (must be http/https)."),
+			format: z
+				.enum(["auto", "markdown", "json", "text"])
+				.optional()
+				.default("auto")
+				.describe(
+					"'auto' selects based on Content-Type. 'markdown' forces HTML→markdown. " +
+						"'json' pretty-prints JSON. 'text' returns raw text.",
+				),
+			selector: z
+				.string()
+				.optional()
+				.describe(
+					"CSS selector to extract only a portion of the page (e.g., '#readme', 'article').",
+				),
+		}),
+		async execute(input) {
+			// ── Domain validation ──────────────────────────────
+			const parsedUrl = new URL(input.url);
+			const domain = parsedUrl.hostname;
+
+			if (isPrivateHost(domain)) {
+				return {
+					type: "error-text" as const,
+					value:
+						"SSRF blocked: cannot fetch from private/internal addresses " +
+						`(${domain}). Only public URLs are allowed.`,
+				};
+			}
+
+			if (allowedDomains.length > 0 && !allowedDomains.includes(domain)) {
+				return {
+					type: "error-text" as const,
+					value:
+						`Domain "${domain}" is not in the allowed domains list. ` +
+						"Configure allowedDomains in WebToolsConfig to enable it.",
+				};
+			}
+
+			if (blockedDomains.includes(domain)) {
+				return {
+					type: "error-text" as const,
+					value:
+						`Domain "${domain}" is blocked. Remove it from blockedDomains ` +
+						"in WebToolsConfig to allow requests.",
+				};
+			}
+
+			// ── Rate limit ─────────────────────────────────────
+			if (!checkRateLimit(domain, rateLimitPerDomain, rateLimitWindow)) {
+				return {
+					type: "error-text" as const,
+					value:
+						`Rate limit exceeded for ${domain}: ` +
+						`${rateLimitPerDomain} requests per ${rateLimitWindow / 1000}s. ` +
+						"Wait before retrying or increase rateLimitPerDomain.",
+				};
+			}
+
+			// ── Cache check ────────────────────────────────────
+			const cached = await cache.get(input.url);
+			if (cached) {
+				return { type: "json" as const, value: { ...cached, cached: true } };
+			}
+
+			// ── Fetch ──────────────────────────────────────────
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), timeout);
+
+			try {
+				const response = await fetch(input.url, {
+					signal: controller.signal,
+					headers: { "User-Agent": userAgent },
+				});
+
+				if (!response.ok) {
+					return {
+						type: "error-text" as const,
+						value: `HTTP ${response.status} ${response.statusText} for ${input.url}`,
+					};
+				}
+
+				const contentType =
+					response.headers.get("content-type") ?? "text/plain";
+				const body = await response.text();
+				const format =
+					input.format === "auto" ? detectFormat(contentType) : input.format;
+
+				// ── Process ──────────────────────────────────────
+				let result: FetchResult;
+
+				if (format === "json") {
+					// Validate it's actually JSON
+					try {
+						JSON.parse(body);
+					} catch {
+						return {
+							type: "error-text" as const,
+							value:
+								`Response from ${input.url} is not valid JSON ` +
+								`(Content-Type: ${contentType}). Try format="text".`,
+						};
+					}
+					result = {
+						url: input.url,
+						title: null,
+						content: body,
+						format: "json",
+						excerpt: body.slice(0, 200),
+						size: body.length,
+						cached: false,
+						truncated: body.length > maxSize,
+					};
+				} else if (format === "markdown" || contentType.includes("html")) {
+					const truncated = body.length > maxSize;
+					const html = truncated ? body.slice(0, maxSize) : body;
+
+					if (input.selector) {
+						const extracted = extractBySelector(html, input.selector);
+						if (!extracted) {
+							return {
+								type: "error-text" as const,
+								value:
+									`CSS selector "${input.selector}" matched no elements ` +
+									`on ${input.url}.`,
+							};
+						}
+						result = {
+							url: input.url,
+							title: null,
+							content: extracted,
+							format: "markdown",
+							excerpt: extracted.slice(0, 200),
+							size: extracted.length,
+							cached: false,
+							truncated: false,
+						};
+					} else {
+						const { title, content } = htmlToMarkdown(html, input.url);
+						result = {
+							url: input.url,
+							title,
+							content,
+							format: "markdown",
+							excerpt: content.slice(0, 200),
+							size: content.length,
+							cached: false,
+							truncated,
+						};
+					}
+				} else {
+					result = {
+						url: input.url,
+						title: null,
+						content: body,
+						format: "text",
+						excerpt: body.slice(0, 200),
+						size: body.length,
+						cached: false,
+						truncated: body.length > maxSize,
+					};
+				}
+
+				// ── Cache ────────────────────────────────────────
+				await cache.set(input.url, result);
+
+				return { type: "json" as const, value: result };
+			} catch (err) {
+				const message =
+					err instanceof Error
+						? err.name === "AbortError"
+							? `Request timed out after ${timeout}ms for ${input.url}`
+							: err.message
+						: String(err);
+				return {
+					type: "error-text" as const,
+					value: `Failed to fetch ${input.url}: ${message}`,
+				};
+			} finally {
+				clearTimeout(timer);
+			}
+		},
+	});
+}
+
+/* ── Helpers ────────────────────────────────────────────── */
+
+function detectFormat(contentType: string): "markdown" | "json" | "text" {
+	const ct = contentType.toLowerCase();
+	if (ct.includes("json")) return "json";
+	if (ct.includes("html")) return "markdown";
+	return "text";
+}

package/src/web-search.ts

@@ -0,0 +1,122 @@
+/**
+ * web_search tool — search the web and return results.
+ *
+ * Default backend: DuckDuckGo HTML search (https://html.duckduckgo.com/html).
+ * No API key needed. Configurable to use any search endpoint.
+ */
+
+import { z } from "zod";
+import { Tool } from "@dex-ai/sdk";
+import { extractSearchResults } from "./render";
+import type { WebToolsConfig, SearchResult } from "./types";
+import { DEFAULTS } from "./types";
+
+/* ── Tool factory ───────────────────────────────────────── */
+
+export function createWebSearchTool(
+	config: WebToolsConfig,
+): ReturnType<typeof Tool.define> {
+	const userAgent = config.userAgent ?? DEFAULTS.userAgent;
+	const searchEndpoint =
+		config.searchEndpoint ?? "https://html.duckduckgo.com/html";
+	const searchApiKey = config.searchApiKey;
+	const timeout = config.timeout ?? DEFAULTS.timeout;
+
+	return Tool.define({
+		name: "web_search",
+		displayName: "Web Search",
+		description:
+			"Search the web and return matching results with title, URL, and snippet. " +
+			"Uses DuckDuckGo by default (no API key needed). " +
+			"Use 'site:domain.com' in your query to scope results to a specific domain.",
+		access: "read" as const,
+		parameters: z.object({
+			query: z.string().min(1).describe("The search query."),
+			count: z
+				.number()
+				.min(1)
+				.max(20)
+				.optional()
+				.default(5)
+				.describe("Number of results to return (1-20)."),
+			site: z
+				.string()
+				.optional()
+				.describe("Scope search to a specific domain (e.g., 'docs.rs')."),
+		}),
+		async execute(input) {
+			const fullQuery = input.site
+				? `site:${input.site} ${input.query}`
+				: input.query;
+			const body = new URLSearchParams({ q: fullQuery });
+
+			const headers: Record<string, string> = {
+				"User-Agent": userAgent,
+				"Content-Type": "application/x-www-form-urlencoded",
+			};
+
+			// Some search APIs use Authorization header
+			if (searchApiKey) {
+				headers["Authorization"] = `Bearer ${searchApiKey}`;
+			}
+
+			const controller = new AbortController();
+			const timer = setTimeout(() => controller.abort(), timeout);
+
+			try {
+				const response = await fetch(searchEndpoint, {
+					method: "POST",
+					headers,
+					body,
+					signal: controller.signal,
+				});
+
+				if (!response.ok) {
+					return {
+						type: "error-text" as const,
+						value:
+							`Search API returned HTTP ${response.status} ${response.statusText}. ` +
+							"Check your searchEndpoint configuration.",
+					};
+				}
+
+				const html = await response.text();
+				const results = extractSearchResults(html).slice(0, input.count);
+
+				if (results.length === 0) {
+					return {
+						type: "text" as const,
+						value:
+							`No search results found for "${input.query}"${input.site ? ` on ${input.site}` : ""}. ` +
+							"Try rephrasing your query or using different terms.",
+					};
+				}
+
+				const formatted = results
+					.map(
+						(r: SearchResult, i: number) =>
+							`${i + 1}. [${r.title}](${r.url})\n   ${r.snippet}`,
+					)
+					.join("\n\n");
+
+				return {
+					type: "text" as const,
+					value: `Search results for "${input.query}"${input.site ? ` (site:${input.site})` : ""}:\n\n${formatted}`,
+				};
+			} catch (err) {
+				const message =
+					err instanceof Error
+						? err.name === "AbortError"
+							? `Search request timed out after ${timeout}ms`
+							: err.message
+						: String(err);
+				return {
+					type: "error-text" as const,
+					value: `Search failed: ${message}`,
+				};
+			} finally {
+				clearTimeout(timer);
+			}
+		},
+	});
+}