@openclaw/tavily-plugin 0.0.0 → 2026.6.11

package/README.md

@@ -1,3 +1,13 @@
-# @openclaw/tavily-plugin
+# Tavily OpenClaw plugin
 
-Bootstrap reservation for the OpenClaw Tavily plugin package.
+Official OpenClaw plugin for Tavily.
+
+## Install
+
+```sh
+openclaw plugins install @openclaw/tavily-plugin
+```
+
+## Docs
+
+See `docs/tools/tavily.md` in the OpenClaw repository, or the published docs at `https://docs.openclaw.ai/tools/tavily`.

package/dist/index.js

@@ -0,0 +1,126 @@
+import { n as runTavilySearch, t as runTavilyExtract } from "./tavily-client-DpdYkDC3.js";
+import { t as createTavilyWebSearchProvider } from "./tavily-search-provider-kDrLCYmR.js";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { jsonResult, readPositiveIntegerParam, readStringParam } from "openclaw/plugin-sdk/provider-web-search";
+import { Type } from "typebox";
+import { optionalStringEnum } from "openclaw/plugin-sdk/channel-actions";
+//#region extensions/tavily/src/tavily-tool-config.ts
+function resolveTavilyToolConfig(api, ctx) {
+	return ctx?.getRuntimeConfig?.() ?? ctx?.runtimeConfig ?? ctx?.config ?? api.config;
+}
+//#endregion
+//#region extensions/tavily/src/tavily-extract-tool.ts
+const TavilyExtractToolSchema = Type.Object({
+	urls: Type.Array(Type.String(), {
+		description: "One or more URLs to extract content from (max 20).",
+		minItems: 1,
+		maxItems: 20
+	}),
+	query: Type.Optional(Type.String({ description: "Rerank extracted chunks by relevance to this query." })),
+	extract_depth: optionalStringEnum(["basic", "advanced"], { description: "\"basic\" (default) or \"advanced\" (for JS-heavy pages)." }),
+	chunks_per_source: Type.Optional(Type.Integer({
+		description: "Chunks per URL (1-5, requires query).",
+		minimum: 1,
+		maximum: 5
+	})),
+	include_images: Type.Optional(Type.Boolean({ description: "Include image URLs in extraction results." }))
+}, { additionalProperties: false });
+function createTavilyExtractTool(api, ctx) {
+	return {
+		name: "tavily_extract",
+		label: "Tavily Extract",
+		description: "Extract clean content from one or more URLs using Tavily. Handles JS-rendered pages. Supports query-focused chunking.",
+		parameters: TavilyExtractToolSchema,
+		execute: async (_toolCallId, rawParams) => {
+			const urls = Array.isArray(rawParams.urls) ? rawParams.urls.filter(Boolean) : [];
+			if (urls.length === 0) throw new Error("tavily_extract requires at least one URL.");
+			const query = readStringParam(rawParams, "query") || void 0;
+			const extractDepth = readStringParam(rawParams, "extract_depth") || void 0;
+			const chunksPerSource = readPositiveIntegerParam(rawParams, "chunks_per_source", {
+				max: 5,
+				message: "chunks_per_source must be an integer from 1 to 5."
+			});
+			if (chunksPerSource !== void 0 && !query) throw new Error("tavily_extract requires query when chunks_per_source is set.");
+			const includeImages = rawParams.include_images === true;
+			return jsonResult(await runTavilyExtract({
+				cfg: resolveTavilyToolConfig(api, ctx),
+				urls,
+				query,
+				extractDepth,
+				chunksPerSource,
+				includeImages
+			}));
+		}
+	};
+}
+//#endregion
+//#region extensions/tavily/src/tavily-search-tool.ts
+const TavilySearchToolSchema = Type.Object({
+	query: Type.String({ description: "Search query string." }),
+	search_depth: optionalStringEnum(["basic", "advanced"], { description: "Search depth: \"basic\" (default, faster) or \"advanced\" (more thorough)." }),
+	topic: optionalStringEnum([
+		"general",
+		"news",
+		"finance"
+	], { description: "Search topic: \"general\" (default), \"news\", or \"finance\"." }),
+	max_results: Type.Optional(Type.Integer({
+		description: "Number of results to return (1-20).",
+		minimum: 1,
+		maximum: 20
+	})),
+	include_answer: Type.Optional(Type.Boolean({ description: "Include an AI-generated answer summary (default: false)." })),
+	time_range: optionalStringEnum([
+		"day",
+		"week",
+		"month",
+		"year"
+	], { description: "Filter results by recency: 'day', 'week', 'month', or 'year'." }),
+	include_domains: Type.Optional(Type.Array(Type.String(), { description: "Only include results from these domains." })),
+	exclude_domains: Type.Optional(Type.Array(Type.String(), { description: "Exclude results from these domains." }))
+}, { additionalProperties: false });
+function createTavilySearchTool(api, ctx) {
+	return {
+		name: "tavily_search",
+		label: "Tavily Search",
+		description: "Search the web using Tavily Search API. Supports search depth, topic filtering, domain filters, time ranges, and AI answer summaries.",
+		parameters: TavilySearchToolSchema,
+		execute: async (_toolCallId, rawParams) => {
+			const query = readStringParam(rawParams, "query", { required: true });
+			const searchDepth = readStringParam(rawParams, "search_depth") || void 0;
+			const topic = readStringParam(rawParams, "topic") || void 0;
+			const maxResults = readPositiveIntegerParam(rawParams, "max_results", {
+				max: 20,
+				message: "max_results must be an integer from 1 to 20."
+			});
+			const includeAnswer = rawParams.include_answer === true;
+			const timeRange = readStringParam(rawParams, "time_range") || void 0;
+			const includeDomains = Array.isArray(rawParams.include_domains) ? rawParams.include_domains.filter(Boolean) : void 0;
+			const excludeDomains = Array.isArray(rawParams.exclude_domains) ? rawParams.exclude_domains.filter(Boolean) : void 0;
+			return jsonResult(await runTavilySearch({
+				cfg: resolveTavilyToolConfig(api, ctx),
+				query,
+				searchDepth,
+				topic,
+				maxResults,
+				includeAnswer,
+				timeRange,
+				includeDomains: includeDomains?.length ? includeDomains : void 0,
+				excludeDomains: excludeDomains?.length ? excludeDomains : void 0
+			}));
+		}
+	};
+}
+//#endregion
+//#region extensions/tavily/index.ts
+var tavily_default = definePluginEntry({
+	id: "tavily",
+	name: "Tavily Plugin",
+	description: "Bundled Tavily search and extract plugin",
+	register(api) {
+		api.registerWebSearchProvider(createTavilyWebSearchProvider());
+		api.registerTool((ctx) => createTavilySearchTool(api, ctx), { name: "tavily_search" });
+		api.registerTool((ctx) => createTavilyExtractTool(api, ctx), { name: "tavily_extract" });
+	}
+});
+//#endregion
+export { tavily_default as default };

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/tavily-client-DpdYkDC3.js

@@ -0,0 +1,202 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { DEFAULT_CACHE_TTL_MINUTES, normalizeCacheKey, postTrustedWebToolsJson, readCache, resolveCacheTtlMs, resolvePositiveTimeoutSeconds, writeCache } from "openclaw/plugin-sdk/provider-web-search";
+import { wrapExternalContent, wrapWebContent } from "openclaw/plugin-sdk/security-runtime";
+import { normalizeResolvedSecretInputString, normalizeSecretInput } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/tavily/src/config.ts
+const DEFAULT_TAVILY_BASE_URL = "https://api.tavily.com";
+function resolveTavilySearchConfig(cfg) {
+	const pluginWebSearch = (cfg?.plugins?.entries?.tavily?.config)?.webSearch;
+	if (pluginWebSearch && typeof pluginWebSearch === "object" && !Array.isArray(pluginWebSearch)) return pluginWebSearch;
+}
+function normalizeConfiguredSecret(value, path) {
+	return normalizeSecretInput(normalizeResolvedSecretInputString({
+		value,
+		path
+	}));
+}
+function resolveTavilyApiKey(cfg) {
+	return normalizeConfiguredSecret(resolveTavilySearchConfig(cfg)?.apiKey, "plugins.entries.tavily.config.webSearch.apiKey") || normalizeSecretInput(process.env.TAVILY_API_KEY) || void 0;
+}
+function resolveTavilyBaseUrl(cfg) {
+	return (normalizeOptionalString(resolveTavilySearchConfig(cfg)?.baseUrl) ?? "") || normalizeSecretInput(process.env.TAVILY_BASE_URL) || "https://api.tavily.com";
+}
+function resolveTavilySearchTimeoutSeconds(override) {
+	return resolvePositiveTimeoutSeconds(override, 30);
+}
+function resolveTavilyExtractTimeoutSeconds(override) {
+	return resolvePositiveTimeoutSeconds(override, 60);
+}
+//#endregion
+//#region extensions/tavily/src/tavily-client.ts
+var tavily_client_exports = /* @__PURE__ */ __exportAll({
+	__testing: () => testing,
+	runTavilyExtract: () => runTavilyExtract,
+	runTavilySearch: () => runTavilySearch,
+	testing: () => testing
+});
+const SEARCH_CACHE = /* @__PURE__ */ new Map();
+const EXTRACT_CACHE = /* @__PURE__ */ new Map();
+const DEFAULT_SEARCH_COUNT = 5;
+function resolveEndpoint(baseUrl, pathname) {
+	const trimmed = baseUrl.trim();
+	if (!trimmed) return `${DEFAULT_TAVILY_BASE_URL}${pathname}`;
+	try {
+		const url = new URL(trimmed);
+		url.pathname = url.pathname.replace(/\/$/, "") + pathname;
+		return url.toString();
+	} catch {
+		return `${DEFAULT_TAVILY_BASE_URL}${pathname}`;
+	}
+}
+async function postTavilyJson(params) {
+	return postTrustedWebToolsJson({
+		url: resolveEndpoint(params.baseUrl, params.pathname),
+		timeoutSeconds: params.timeoutSeconds,
+		apiKey: params.apiKey,
+		body: params.body,
+		errorLabel: params.errorLabel,
+		extraHeaders: { "X-Client-Source": "openclaw" }
+	}, async (response) => readTavilyJsonResponse(response, params.errorLabel));
+}
+async function readTavilyJsonResponse(response, label) {
+	try {
+		return await response.json();
+	} catch (cause) {
+		throw new Error(`${label}: malformed JSON response`, { cause });
+	}
+}
+async function runTavilySearch(params) {
+	const apiKey = resolveTavilyApiKey(params.cfg);
+	if (!apiKey) throw new Error("web_search (tavily) needs a Tavily API key. Set TAVILY_API_KEY in the Gateway environment, or configure plugins.entries.tavily.config.webSearch.apiKey.");
+	const count = typeof params.maxResults === "number" && Number.isFinite(params.maxResults) ? Math.max(1, Math.min(20, Math.floor(params.maxResults))) : DEFAULT_SEARCH_COUNT;
+	const timeoutSeconds = resolveTavilySearchTimeoutSeconds(params.timeoutSeconds);
+	const baseUrl = resolveTavilyBaseUrl(params.cfg);
+	const cacheKey = normalizeCacheKey(JSON.stringify({
+		type: "tavily-search",
+		q: params.query,
+		count,
+		baseUrl,
+		searchDepth: params.searchDepth,
+		topic: params.topic,
+		includeAnswer: params.includeAnswer,
+		timeRange: params.timeRange,
+		includeDomains: params.includeDomains,
+		excludeDomains: params.excludeDomains
+	}));
+	const cached = readCache(SEARCH_CACHE, cacheKey);
+	if (cached) return {
+		...cached.value,
+		cached: true
+	};
+	const body = {
+		query: params.query,
+		max_results: count
+	};
+	if (params.searchDepth) body.search_depth = params.searchDepth;
+	if (params.topic) body.topic = params.topic;
+	if (params.includeAnswer) body.include_answer = true;
+	if (params.timeRange) body.time_range = params.timeRange;
+	if (params.includeDomains?.length) body.include_domains = params.includeDomains;
+	if (params.excludeDomains?.length) body.exclude_domains = params.excludeDomains;
+	const start = Date.now();
+	const payload = await postTavilyJson({
+		baseUrl,
+		pathname: "/search",
+		timeoutSeconds,
+		apiKey,
+		body,
+		errorLabel: "Tavily Search"
+	});
+	const results = (Array.isArray(payload.results) ? payload.results : []).map((r) => Object.assign({
+		title: typeof r.title === `string` ? wrapWebContent(r.title, `web_search`) : ``,
+		url: typeof r.url === `string` ? r.url : ``,
+		snippet: typeof r.content === `string` ? wrapWebContent(r.content, `web_search`) : ``,
+		score: typeof r.score === `number` ? r.score : void 0
+	}, typeof r.published_date === `string` ? { published: r.published_date } : {}));
+	const result = {
+		query: params.query,
+		provider: "tavily",
+		count: results.length,
+		tookMs: Date.now() - start,
+		externalContent: {
+			untrusted: true,
+			source: "web_search",
+			provider: "tavily",
+			wrapped: true
+		},
+		results
+	};
+	if (typeof payload.answer === "string" && payload.answer) result.answer = wrapWebContent(payload.answer, "web_search");
+	writeCache(SEARCH_CACHE, cacheKey, result, resolveCacheTtlMs(void 0, DEFAULT_CACHE_TTL_MINUTES));
+	return result;
+}
+async function runTavilyExtract(params) {
+	const apiKey = resolveTavilyApiKey(params.cfg);
+	if (!apiKey) throw new Error("tavily_extract needs a Tavily API key. Set TAVILY_API_KEY in the Gateway environment, or configure plugins.entries.tavily.config.webSearch.apiKey.");
+	const baseUrl = resolveTavilyBaseUrl(params.cfg);
+	const timeoutSeconds = resolveTavilyExtractTimeoutSeconds(params.timeoutSeconds);
+	const cacheKey = normalizeCacheKey(JSON.stringify({
+		type: "tavily-extract",
+		urls: params.urls,
+		baseUrl,
+		query: params.query,
+		extractDepth: params.extractDepth,
+		chunksPerSource: params.chunksPerSource,
+		includeImages: params.includeImages
+	}));
+	const cached = readCache(EXTRACT_CACHE, cacheKey);
+	if (cached) return {
+		...cached.value,
+		cached: true
+	};
+	const body = { urls: params.urls };
+	if (params.query) body.query = params.query;
+	if (params.extractDepth) body.extract_depth = params.extractDepth;
+	if (params.chunksPerSource) body.chunks_per_source = params.chunksPerSource;
+	if (params.includeImages) body.include_images = true;
+	const start = Date.now();
+	const payload = await postTavilyJson({
+		baseUrl,
+		pathname: "/extract",
+		timeoutSeconds,
+		apiKey,
+		body,
+		errorLabel: "Tavily Extract"
+	});
+	const results = (Array.isArray(payload.results) ? payload.results : []).map((r) => Object.assign({
+		url: typeof r.url === `string` ? r.url : ``,
+		rawContent: typeof r.raw_content === `string` ? wrapExternalContent(r.raw_content, {
+			source: `web_fetch`,
+			includeWarning: false
+		}) : ``
+	}, typeof r.content === `string` ? { content: wrapExternalContent(r.content, {
+		source: `web_fetch`,
+		includeWarning: false
+	}) } : {}, Array.isArray(r.images) ? { images: r.images.map((img) => wrapExternalContent(img, {
+		source: `web_fetch`,
+		includeWarning: false
+	})) } : {}));
+	const failedResults = Array.isArray(payload.failed_results) ? payload.failed_results : [];
+	const result = {
+		provider: "tavily",
+		count: results.length,
+		tookMs: Date.now() - start,
+		externalContent: {
+			untrusted: true,
+			source: "web_fetch",
+			provider: "tavily",
+			wrapped: true
+		},
+		results,
+		...failedResults.length > 0 ? { failedResults } : {}
+	};
+	writeCache(EXTRACT_CACHE, cacheKey, result, resolveCacheTtlMs(void 0, DEFAULT_CACHE_TTL_MINUTES));
+	return result;
+}
+const testing = {
+	readTavilyJsonResponse,
+	resolveEndpoint
+};
+//#endregion
+export { runTavilySearch as n, tavily_client_exports as r, runTavilyExtract as t };

package/dist/tavily-search-provider-kDrLCYmR.js

@@ -0,0 +1,32 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { TAVILY_GENERIC_SEARCH_DESCRIPTION, TAVILY_GENERIC_SEARCH_SCHEMA, buildTavilyWebSearchProviderBase } from "./web-search-shared.js";
+import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
+//#region extensions/tavily/src/tavily-search-provider.ts
+var tavily_search_provider_exports = /* @__PURE__ */ __exportAll({ createTavilyWebSearchProvider: () => createTavilyWebSearchProvider });
+let tavilyClientModulePromise;
+function loadTavilyClientModule() {
+	tavilyClientModulePromise ??= import("./tavily-client-DpdYkDC3.js").then((n) => n.r);
+	return tavilyClientModulePromise;
+}
+function createTavilyWebSearchProvider() {
+	return {
+		...buildTavilyWebSearchProviderBase(),
+		createTool: (ctx) => ({
+			description: TAVILY_GENERIC_SEARCH_DESCRIPTION,
+			parameters: TAVILY_GENERIC_SEARCH_SCHEMA,
+			execute: async (args) => {
+				const { runTavilySearch } = await loadTavilyClientModule();
+				return await runTavilySearch({
+					cfg: ctx.config,
+					query: typeof args.query === "string" ? args.query : "",
+					maxResults: readPositiveIntegerParam(args, "count", {
+						message: "count must be an integer from 1 to 20",
+						max: 20
+					})
+				});
+			}
+		})
+	};
+}
+//#endregion
+export { tavily_search_provider_exports as n, createTavilyWebSearchProvider as t };

package/dist/web-search-contract-api.js

@@ -0,0 +1,24 @@
+import { TAVILY_GENERIC_SEARCH_DESCRIPTION, TAVILY_GENERIC_SEARCH_SCHEMA, buildTavilyWebSearchProviderBase } from "./web-search-shared.js";
+//#region extensions/tavily/web-search-contract-api.ts
+let tavilySearchProviderModulePromise;
+function loadTavilySearchProviderModule() {
+	tavilySearchProviderModulePromise ??= import("./tavily-search-provider-kDrLCYmR.js").then((n) => n.n);
+	return tavilySearchProviderModulePromise;
+}
+function createTavilyWebSearchProvider() {
+	return {
+		...buildTavilyWebSearchProviderBase(),
+		createTool: (ctx) => ({
+			description: TAVILY_GENERIC_SEARCH_DESCRIPTION,
+			parameters: TAVILY_GENERIC_SEARCH_SCHEMA,
+			execute: async (args) => {
+				const { createTavilyWebSearchProvider: createRuntimeProvider } = await loadTavilySearchProviderModule();
+				const tool = createRuntimeProvider().createTool(ctx);
+				if (!tool) throw new Error("Tavily web_search provider did not create a runtime tool.");
+				return await tool.execute(args);
+			}
+		})
+	};
+}
+//#endregion
+export { createTavilyWebSearchProvider };

package/dist/web-search-provider.js

@@ -0,0 +1,2 @@
+import { t as createTavilyWebSearchProvider } from "./tavily-search-provider-kDrLCYmR.js";
+export { createTavilyWebSearchProvider };

package/dist/web-search-shared.js

@@ -0,0 +1,46 @@
+import { createWebSearchProviderContractFields } from "openclaw/plugin-sdk/provider-web-search-contract";
+//#region extensions/tavily/web-search-shared.ts
+const TAVILY_CREDENTIAL_PATH = "plugins.entries.tavily.config.webSearch.apiKey";
+const TAVILY_GENERIC_SEARCH_DESCRIPTION = "Search the web using Tavily. Returns structured results with snippets. Use tavily_search for Tavily-specific options like search depth, topic filtering, or AI answers.";
+const TAVILY_GENERIC_SEARCH_SCHEMA = {
+	type: "object",
+	properties: {
+		query: {
+			type: "string",
+			description: "Search query string."
+		},
+		count: {
+			type: "integer",
+			description: "Number of results to return (1-20).",
+			minimum: 1,
+			maximum: 20
+		}
+	},
+	additionalProperties: false
+};
+function buildTavilyWebSearchProviderBase() {
+	return {
+		id: "tavily",
+		label: "Tavily Search",
+		hint: "Structured results with domain filters and AI answer summaries",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "Tavily API key",
+		envVars: ["TAVILY_API_KEY"],
+		placeholder: "tvly-...",
+		signupUrl: "https://tavily.com/",
+		docsUrl: "https://docs.openclaw.ai/tools/tavily",
+		autoDetectOrder: 70,
+		credentialPath: TAVILY_CREDENTIAL_PATH,
+		...createWebSearchProviderContractFields({
+			credentialPath: TAVILY_CREDENTIAL_PATH,
+			searchCredential: {
+				type: "scoped",
+				scopeId: "tavily"
+			},
+			configuredCredential: { pluginId: "tavily" },
+			selectionPluginId: "tavily"
+		})
+	};
+}
+//#endregion
+export { TAVILY_CREDENTIAL_PATH, TAVILY_GENERIC_SEARCH_DESCRIPTION, TAVILY_GENERIC_SEARCH_SCHEMA, buildTavilyWebSearchProviderBase };

package/node_modules/typebox/build/compile/code.d.mts

@@ -0,0 +1,12 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { type TExternal } from '../schema/index.mjs';
+export interface CodeResult {
+    /** External Variables  */
+    External: TExternal;
+    /** Generated Esm module. */
+    Code: string;
+}
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Type extends TSchema>(type: Type): CodeResult;
+/** Creates a standalone ESM validation module for the given type. */
+export declare function Code<Context extends TProperties, Type extends TSchema>(context: Context, type: Type): CodeResult;

package/node_modules/typebox/build/compile/code.mjs

@@ -0,0 +1,65 @@
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Build } from '../schema/index.mjs';
+// ------------------------------------------------------------------
+// Comments and Formatting
+// ------------------------------------------------------------------
+function TsIgnore() {
+    return `// @ts-ignore`;
+}
+function Separator() {
+    return ``;
+}
+// ------------------------------------------------------------------
+// ImportSection
+// ------------------------------------------------------------------
+function ImportSection(build) {
+    const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
+    const hashing = `import { Hashing } from "typebox/system"`;
+    const format = `import { Format } from "typebox/format"`;
+    const guard = `import { Guard } from "typebox/guard"`;
+    return [...context, hashing, format, guard];
+}
+// ------------------------------------------------------------------
+// ExternalSection
+// ------------------------------------------------------------------
+function ExternalSection(build) {
+    const { identifier } = build.External();
+    return [
+        Separator(),
+        TsIgnore(),
+        `let ${identifier} = []`,
+        Separator(),
+        TsIgnore(),
+        `export function SetExternal(external) { ${identifier} = external.variables }`
+    ];
+}
+// ------------------------------------------------------------------
+// FunctionSection
+// ------------------------------------------------------------------
+function FunctionSection(build) {
+    return build.Functions().map((func) => [Separator(), TsIgnore(), `${func};`].join('\n'));
+}
+// ------------------------------------------------------------------
+// ExportSection
+// ------------------------------------------------------------------
+function ExportSection(build) {
+    const body = build.UseUnevaluated()
+        ? `const context = new CheckContext({}, {}); return ${build.Entry()}`
+        : `return ${build.Entry()}`;
+    return [
+        Separator(),
+        TsIgnore(),
+        `export function Check(value) { ${body} }`
+    ];
+}
+/** Creates a standalone ESM validation module for the given type. */
+export function Code(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    const build = Build(context, type);
+    const code = [...ImportSection(build), ...ExternalSection(build), ...FunctionSection(build), ...ExportSection(build)].join('\n');
+    return { External: build.External(), Code: code };
+}

package/node_modules/typebox/build/compile/compile.d.mts

@@ -0,0 +1,6 @@
+import { type TProperties, type TSchema } from '../type/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
+/** Compiles a type into a high performance Validator */
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/node_modules/typebox/build/compile/compile.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Validator } from './validator.mjs';
+/** Compiles a type into a high performance Validator */
+export function Compile(...args) {
+    const [context, type] = Arguments.Match(args, {
+        2: (context, type) => [context, type],
+        1: (type) => [{}, type]
+    });
+    return new Validator(context, type);
+}

package/node_modules/typebox/build/compile/index.d.mts

@@ -0,0 +1,8 @@
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// Barrel
+// ------------------------------------------------------------------
+export * from './code.mjs';
+export * from './compile.mjs';
+export * from './validator.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
+import { Code } from './code.mjs';
+import { Compile } from './compile.mjs';
+import { Validator } from './validator.mjs';
+export { Code, Compile, Validator };
+export default Compile;

package/node_modules/typebox/build/compile/validator.d.mts

@@ -0,0 +1,43 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
+import { BuildResult, EvaluateResult } from '../schema/index.mjs';
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
+    private readonly hasCodec;
+    private readonly buildResult;
+    private readonly evaluateResult;
+    /** Constructs a Validator with the given Context and Type. */
+    constructor(context: Context, type: Type);
+    /** Constructs a Validator with the given arguments. */
+    constructor(hasCodec: boolean, buildResult: BuildResult, evaluateResult: EvaluateResult);
+    /** Returns true if this Validator is using JIT acceleration. */
+    IsAccelerated(): boolean;
+    /** Returns the Context for this validator. */
+    Context(): Context;
+    /** Returns the underlying Type used to construct this Validator. */
+    Type(): Type;
+    /** Returns the generated code for this validator. */
+    Code(): string;
+    /** Performs a type-guard check on the provided value. */
+    Check(value: unknown): value is Encode;
+    /** Validates a value and returns it. Will throw if invalid. */
+    Parse(value: unknown): Encode;
+    /** Inspects a value and returns a detailed list of validation errors. */
+    Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
+    Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
+    Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
+    Create(): Encode;
+    /** Creates defaults using the Validator type. */
+    Default(value: unknown): unknown;
+    /** Decodes a value */
+    Decode(value: unknown): Decode;
+    /** Encodes a value */
+    Encode(value: unknown): Encode;
+    /**
+     * @deprecated Validator instances should not support Clone because they are owners of JIT evaluated functions. This function will be
+     * removed in the next version of TypeBox (relates to Type.Base deprecation)
+     */
+    Clone(): Validator<Context, Type>;
+}