@wervt/nuxt 0.2.8 → 0.2.9

package/README.md

@@ -19,6 +19,7 @@ export default defineNuxtConfig({
 - `proxyShape()` (server) and `useShape()` (app): live rows from Postgres via Electric.
 - `useWervtUser()`: the signed-in wervt user, on the server and in the app.
 - `useValidatedBody()` / `useValidatedQuery()` / `useValidatedParams()`: valibot validation.
+- `defineTool()` (server): tools in `server/tools/` that browser agents call through WebMCP.
 - `nuxt dev` starts against the local wervt stack (Postgres, Electric) and a dev user.
 
 Deploy with [`@wervt/cli`](https://www.npmjs.com/package/@wervt/cli): `wervt deploy`.

package/dist/module.d.ts

@@ -7,6 +7,17 @@ export interface ModuleOptions {
   dev?: DevOptions;
   /** Time zone of `nitro.scheduledTasks`, e.g. `Europe/Berlin`. Defaults to UTC. */
   timezone?: string;
+  /**
+   * When a new release is live while the app is open: `'banner'` (default) shows a small
+   * "A new version is available · Reload" banner, `'manual'` only sets `useWervtUpdate()` for
+   * the app's own banner, `false` leaves it to Nuxt (reload on the next navigation, hourly).
+   */
+  updates?: 'banner' | 'manual' | false;
+  /**
+   * Registers the tools in `server/tools/` (`defineTool`) with browser agents through WebMCP.
+   * Defaults to true; `false` leaves them out of the build.
+   */
+  webmcp?: boolean;
 }
 /** `server/wervt-tasks.json` in the build: the app's tasks and schedules, for the control plane. */
 export interface TasksManifest {

package/dist/module.js

@@ -1,8 +1,8 @@
 import { resolveAppName, setupDev } from "./dev.js";
-import { addImports, addPlugin, addServerHandler, addServerPlugin, createResolver, defineNuxtModule, getNuxtVersion, hasNuxtModule, installModule } from "nuxt/kit";
-import { mkdir, writeFile } from "node:fs/promises";
+import { addImports, addPlugin, addServerHandler, addServerPlugin, addServerTemplate, createResolver, defineNuxtModule, getNuxtVersion, hasNuxtModule, installModule } from "nuxt/kit";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
 import { builtinModules, createRequire } from "node:module";
-import { dirname, join } from "node:path";
+import { dirname, extname, join, relative, resolve, sep } from "node:path";
 import evlog from "evlog/nuxt";
 //#region src/module.ts
 const CONTENT_DATABASE = {
@@ -61,7 +61,7 @@ var module_default = defineNuxtModule({
 				inline: [
 					...options.externals?.inline ?? [],
 					resolver.resolve("./runtime"),
-					/(^|\/node_modules\/)(drizzle-orm|postgres|valibot|@electric-sql\/client|evlog)(\/|$)/
+					/(^|\/node_modules\/)(drizzle-orm|postgres|valibot|@valibot\/to-json-schema|@electric-sql\/client|evlog)(\/|$)/
 				]
 			};
 			const exclude = options.esbuild?.options?.exclude ?? /node_modules/;
@@ -161,6 +161,32 @@ var module_default = defineNuxtModule({
 				});
 			});
 		}
+		const toolsDir = join(nuxt.options.serverDir, "tools");
+		const tools = options.webmcp === false ? [] : await findTools(toolsDir);
+		if (tools.length > 0) {
+			addServerTemplate({
+				filename: "#wervt/tools",
+				getContents: () => `export const tools = {\n${tools.map(({ name, path }) => `  ${JSON.stringify(name)}: () => import(${JSON.stringify(path)}),`).join("\n")}\n}\n`
+			});
+			addServerHandler({
+				route: "/_wervt/tools",
+				method: "get",
+				handler: resolver.resolve("./runtime/server/tool-list")
+			});
+			addServerHandler({
+				route: "/_wervt/tools/**",
+				method: "post",
+				handler: resolver.resolve("./runtime/server/tool-run")
+			});
+			addPlugin({
+				src: resolver.resolve("./runtime/app/plugins/webmcp.client"),
+				mode: "client"
+			});
+		}
+		if (nuxt.options.dev && options.webmcp !== false) nuxt.hook("builder:watch", async (event, path) => {
+			const file = relative(toolsDir, resolve(nuxt.options.srcDir, path));
+			if ((event === "add" || event === "unlink") && !file.startsWith("..")) await nuxt.callHook("restart");
+		});
 		if (nuxt.options.dev && !nuxt.options._prepare) {
 			const app = await resolveAppName(nuxt.options.rootDir, options.app);
 			await setupDev(nuxt, app, options.dev ?? {}, { storage: useAblage });
@@ -178,6 +204,19 @@ var module_default = defineNuxtModule({
 			src: resolver.resolve("./runtime/app/plugins/user.client"),
 			mode: "client"
 		});
+		const updates = options.updates ?? "banner";
+		if (updates && !nuxt.options.dev) {
+			nuxt.options.experimental.checkOutdatedBuildInterval = false;
+			const config = nuxt.options.runtimeConfig.public;
+			config.wervt = {
+				...config.wervt,
+				updates
+			};
+			addPlugin({
+				src: resolver.resolve("./runtime/app/plugins/update.client"),
+				mode: "client"
+			});
+		}
 		nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
 		addImports([
 			{
@@ -195,10 +234,40 @@ var module_default = defineNuxtModule({
 			{
 				name: "wervtLogoutUrl",
 				from: resolver.resolve("./runtime/app/useWervtUser")
+			},
+			{
+				name: "useWervtUpdate",
+				from: resolver.resolve("./runtime/app/useWervtUpdate")
 			}
 		]);
 	}
 });
+const TOOL_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".js",
+	".mts",
+	".mjs"
+]);
+const TOOL_NAME_RE = /^[\w.-]{1,128}$/;
+/** The tools in `server/tools/`: `todos/add.ts` is `todos.add`, like Nitro names tasks. */
+async function findTools(dir) {
+	const files = await readdir(dir, { recursive: true }).catch(() => []);
+	const tools = [];
+	for (const file of files.toSorted((a, b) => a.localeCompare(b))) {
+		const ext = extname(file);
+		if (!TOOL_EXTENSIONS.has(ext) || file.endsWith(`.d${ext}`)) continue;
+		const name = file.slice(0, -ext.length).split(sep).join(".");
+		if (!TOOL_NAME_RE.test(name)) {
+			console.warn(`[wervt] Skipping server/tools/${file}: tool names can only use A-Z, 0-9, _ and -.`);
+			continue;
+		}
+		tools.push({
+			name,
+			path: join(dir, file)
+		});
+	}
+	return tools;
+}
 /** evlog's Nitro 2 plugin and error handler, as evlog/nuxt resolves them. */
 const EVLOG_NITRO2_RE = /([\\/]evlog[\\/]dist[\\/]nitro)[\\/](plugin|errorHandler)(\.mjs)?$/;
 const BUILTINS = new Set(builtinModules.filter((name) => !name.startsWith("_")));

package/dist/runtime/app/plugins/update.client.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/app/plugins/update.client.d.ts
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/app/plugins/update.client.js

@@ -0,0 +1,78 @@
+import { useUpdateAvailable, useWervtUpdate } from "../useWervtUpdate.js";
+import { defineNuxtPlugin, getAppManifest, onNuxtReady, useRuntimeConfig } from "#app";
+//#region src/runtime/app/plugins/update.client.ts
+const INTERVAL_MS = 6e4;
+/** Focus and visibility changes come in bursts; one check covers them. */
+const MIN_GAP_MS = 1e4;
+var update_client_default = defineNuxtPlugin({
+	name: "wervt:update",
+	setup(nuxtApp) {
+		const config = useRuntimeConfig();
+		const mode = config.public.wervt?.updates;
+		const available = useUpdateAvailable();
+		const url = `${(config.app.cdnURL || config.app.baseURL).replace(/\/$/, "")}/${config.app.buildAssetsDir.replace(/^\/|\/$/g, "")}/builds/latest.json`;
+		let last = 0;
+		async function check() {
+			if (available.value || document.hidden || Date.now() - last < MIN_GAP_MS) return;
+			last = Date.now();
+			try {
+				const current = await getAppManifest();
+				const res = await fetch(`${url}?${last}`, {
+					cache: "no-store",
+					signal: AbortSignal.timeout(1e4)
+				});
+				if (!res.ok) return;
+				const latest = await res.json();
+				if (!latest.id || latest.id === current.id) return;
+				available.value = true;
+				await nuxtApp.callHook("app:manifest:update", latest);
+				if (mode === "banner") showBanner(useWervtUpdate().reload);
+			} catch {}
+		}
+		onNuxtReady(() => {
+			setInterval(check, INTERVAL_MS);
+			document.addEventListener("visibilitychange", check);
+			window.addEventListener("focus", check);
+		});
+	}
+});
+/** A small pill at the bottom, plain DOM so it works with any styling (or none). */
+function showBanner(reload) {
+	if (document.getElementById("wervt-update")) return;
+	const bar = document.createElement("div");
+	bar.id = "wervt-update";
+	bar.setAttribute("role", "status");
+	bar.style.cssText = [
+		"position:fixed",
+		"left:50%",
+		"bottom:max(16px, env(safe-area-inset-bottom))",
+		"transform:translateX(-50%)",
+		"z-index:2147483647",
+		"display:flex",
+		"align-items:center",
+		"gap:8px",
+		"padding:6px 6px 6px 16px",
+		"border-radius:999px",
+		"background:#18181b",
+		"color:#fafafa",
+		"font:500 14px/1.4 system-ui, sans-serif",
+		"box-shadow:0 4px 16px rgb(0 0 0 / 0.25)",
+		"white-space:nowrap"
+	].join(";");
+	const text = document.createElement("span");
+	text.textContent = "A new version is available";
+	const button = (label, style, onClick) => {
+		const el = document.createElement("button");
+		el.type = "button";
+		el.textContent = label;
+		el.style.cssText = `border:0;border-radius:999px;padding:6px 12px;font:inherit;cursor:pointer;${style}`;
+		el.addEventListener("click", onClick);
+		return el;
+	};
+	const close = button("×", "background:transparent;color:inherit;padding:6px 10px", () => bar.remove());
+	close.setAttribute("aria-label", "Dismiss");
+	bar.append(text, button("Reload", "background:#fafafa;color:#18181b", reload), close);
+	document.body.append(bar);
+}
+//#endregion
+export { update_client_default as default };

package/dist/runtime/app/plugins/webmcp.client.d.ts

@@ -0,0 +1,4 @@
+//#region src/runtime/app/plugins/webmcp.client.d.ts
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+//#endregion
+export { _default as default };

package/dist/runtime/app/plugins/webmcp.client.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin, onNuxtReady, useRuntimeConfig } from "#app";
+//#region src/runtime/app/plugins/webmcp.client.ts
+function pageModelContext() {
+	const context = document.modelContext ?? navigator.modelContext;
+	return typeof context?.registerTool === "function" ? context : void 0;
+}
+var webmcp_client_default = defineNuxtPlugin({
+	name: "wervt:webmcp",
+	setup() {
+		const context = pageModelContext();
+		if (!context) return;
+		const base = useRuntimeConfig().app.baseURL.replace(/\/$/, "");
+		async function execute(name, input) {
+			const res = await fetch(`${base}/_wervt/tools/${encodeURIComponent(name)}`, {
+				method: "POST",
+				headers: { "content-type": "application/json" },
+				body: JSON.stringify(input ?? {})
+			});
+			const body = await res.json().catch(() => void 0);
+			if (res.ok) return body?.result ?? null;
+			const issues = body?.issues ?? body?.data;
+			const message = (typeof body?.error === "string" ? body.error : body?.message) ?? `${res.status} ${res.statusText}`;
+			throw new Error(issues ? `${message} ${JSON.stringify(issues)}` : message);
+		}
+		onNuxtReady(async () => {
+			let tools;
+			try {
+				const res = await fetch(`${base}/_wervt/tools`);
+				if (!res.ok) return;
+				tools = await res.json();
+			} catch {
+				return;
+			}
+			for (const tool of tools) try {
+				const result = context.registerTool({
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema,
+					...tool.readOnly ? { annotations: { readOnlyHint: true } } : {},
+					execute: (input) => execute(tool.name, input)
+				});
+				if (result instanceof Promise) result.catch((e) => console.warn(`wervt: could not register tool ${tool.name}`, e));
+			} catch (e) {
+				console.warn(`wervt: could not register tool ${tool.name}`, e);
+			}
+		});
+	}
+});
+//#endregion
+export { webmcp_client_default as default };

package/dist/runtime/app/useWervtUpdate.d.ts

@@ -0,0 +1,13 @@
+//#region src/runtime/app/useWervtUpdate.d.ts
+/** State behind `useWervtUpdate()`, set by the update check (`plugins/update.client`). */
+export declare const useUpdateAvailable: () => import("vue").Ref<boolean, boolean>;
+/**
+ * Whether a newer release of this app is live, and a reload into it. @wervt/nuxt checks every
+ * minute and when the tab comes back to the foreground. With `wervt: { updates: 'manual' }`
+ * the app shows its own banner from this instead of the built-in one.
+ */
+export declare function useWervtUpdate(): {
+  available: Readonly<import("vue").Ref<boolean, boolean>>;
+  reload: () => void;
+};
+//#endregion

package/dist/runtime/app/useWervtUpdate.js

@@ -0,0 +1,21 @@
+import { readonly } from "vue";
+import { reloadNuxtApp, useState } from "#app";
+//#region src/runtime/app/useWervtUpdate.ts
+/** State behind `useWervtUpdate()`, set by the update check (`plugins/update.client`). */
+const useUpdateAvailable = () => useState("wervt-update", () => false);
+/**
+* Whether a newer release of this app is live, and a reload into it. @wervt/nuxt checks every
+* minute and when the tab comes back to the foreground. With `wervt: { updates: 'manual' }`
+* the app shows its own banner from this instead of the built-in one.
+*/
+function useWervtUpdate() {
+	return {
+		available: readonly(useUpdateAvailable()),
+		reload: () => reloadNuxtApp({
+			force: true,
+			persistState: true
+		})
+	};
+}
+//#endregion
+export { useUpdateAvailable, useWervtUpdate };

package/dist/runtime/server/index.d.ts

@@ -3,6 +3,7 @@ import { useDb } from "./db.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
 import { ShapeOptions, proxyShape } from "./shape.js";
 import { Task, TaskEvent, TaskResult, defineTask } from "./tasks.js";
-import { useWervtUser } from "./user.js";
 import { SafeResult, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
-export { type SafeResult, type ShapeOptions, type Task, type TaskEvent, type TaskResult, type WervtUser, createEvlogError, defineTask, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };
+import { Tool, defineTool } from "./tools.js";
+import { useWervtUser } from "./user.js";
+export { type SafeResult, type ShapeOptions, type Task, type TaskEvent, type TaskResult, type Tool, type WervtUser, createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };

package/dist/runtime/server/index.js

@@ -2,6 +2,7 @@ import { useDb } from "./db.js";
 import { createEvlogError, log, useLogger } from "./logger.js";
 import { proxyShape } from "./shape.js";
 import { defineTask } from "./tasks.js";
+import { defineTool } from "./tools.js";
 import { useWervtUser } from "./user.js";
 import { useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh } from "./validate.js";
-export { createEvlogError, defineTask, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };
+export { createEvlogError, defineTask, defineTool, log, proxyShape, useDb, useLogger, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, useWervtUser, vh };

package/dist/runtime/server/tool-handlers.d.ts

@@ -0,0 +1,32 @@
+//#region src/runtime/server/tool-handlers.d.ts
+/** `GET /_wervt/tools`: name, description and JSON Schema of each tool, for the client plugin. */
+export declare const listTools: import("nuxt/server").EventHandler<Promise<{
+  name: string;
+  description: string;
+  inputSchema: import("@valibot/to-json-schema").JsonSchema | {
+    type: string;
+    properties: {};
+  };
+  readOnly: boolean;
+}[]>>;
+/** `POST /_wervt/tools/:name` with the arguments as JSON body: runs the tool's handler. */
+export declare const runTool: import("nuxt/server").EventHandler<Promise<{
+  error: string;
+  issues?: undefined;
+  result?: undefined;
+} | {
+  error: string;
+  issues: {
+    readonly root?: [string, ...string[]] | undefined;
+    readonly nested?: {
+      readonly [x: string]: [string, ...string[]] | undefined;
+    } | undefined;
+    readonly other?: [string, ...string[]] | undefined;
+  };
+  result?: undefined;
+} | {
+  result: {} | null;
+  error?: undefined;
+  issues?: undefined;
+}>>;
+//#endregion

package/dist/runtime/server/tool-handlers.js

@@ -0,0 +1,70 @@
+import { useLogger } from "./logger.js";
+import { safeValidate, toSchema } from "./validate.js";
+import { defineEventHandler } from "nuxt/server";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import { tools } from "#wervt/tools";
+//#region src/runtime/server/tool-handlers.ts
+async function load(name) {
+	return (await (Object.hasOwn(tools, name) ? tools[name] : void 0)?.())?.default;
+}
+function inputSchema(tool) {
+	if (!tool.input) return {
+		type: "object",
+		properties: {}
+	};
+	const schema = toJsonSchema(toSchema(tool.input), {
+		typeMode: "input",
+		errorMode: "ignore"
+	});
+	delete schema.$schema;
+	return schema;
+}
+/** `GET /_wervt/tools`: name, description and JSON Schema of each tool, for the client plugin. */
+const listTools = defineEventHandler(async (event) => {
+	event.res.headers.set("cache-control", "no-store");
+	return (await Promise.all(Object.keys(tools).map(async (name) => {
+		const tool = await load(name);
+		if (!tool) return void 0;
+		return {
+			name,
+			description: tool.description,
+			inputSchema: inputSchema(tool),
+			readOnly: tool.readOnly === true
+		};
+	}))).filter((tool) => tool !== void 0);
+});
+function crossSite(event) {
+	const site = event.req.headers.get("sec-fetch-site");
+	return site !== null && site !== "same-origin";
+}
+/** `POST /_wervt/tools/:name` with the arguments as JSON body: runs the tool's handler. */
+const runTool = defineEventHandler(async (event) => {
+	event.res.headers.set("cache-control", "no-store");
+	if (crossSite(event)) {
+		event.res.status = 403;
+		return { error: "Tools can only be called from the app itself." };
+	}
+	const name = decodeURIComponent(new URL(event.req.url).pathname.split("/").pop() ?? "");
+	const tool = await load(name);
+	if (!tool) {
+		event.res.status = 404;
+		return { error: `No tool named ${name}.` };
+	}
+	useLogger(event).set({ tool: name });
+	const body = await event.req.json().catch(() => void 0);
+	let input;
+	if (tool.input) {
+		const result = await safeValidate(tool.input, body ?? {});
+		if (!result.success) {
+			event.res.status = 400;
+			return {
+				error: "Invalid arguments.",
+				issues: result.issues
+			};
+		}
+		input = result.data;
+	}
+	return { result: await tool.handler(event, input) ?? null };
+});
+//#endregion
+export { listTools, runTool };

package/dist/runtime/server/tool-list.d.ts

@@ -0,0 +1,2 @@
+import { listTools } from "./tool-handlers.js";
+export { listTools as default };

package/dist/runtime/server/tool-list.js

@@ -0,0 +1,5 @@
+import { listTools } from "./tool-handlers.js";
+//#region src/runtime/server/tool-list.ts
+var tool_list_default = listTools;
+//#endregion
+export { tool_list_default as default };

package/dist/runtime/server/tool-run.d.ts

@@ -0,0 +1,2 @@
+import { runTool } from "./tool-handlers.js";
+export { runTool as default };

package/dist/runtime/server/tool-run.js

@@ -0,0 +1,5 @@
+import { runTool } from "./tool-handlers.js";
+//#region src/runtime/server/tool-run.ts
+var tool_run_default = runTool;
+//#endregion
+export { tool_run_default as default };

package/dist/runtime/server/tools.d.ts

@@ -0,0 +1,15 @@
+import { Input, Output } from "./validate.js";
+import { RequestEvent } from "nuxt/server";
+//#region src/runtime/server/tools.d.ts
+export interface Tool<I extends Input | undefined = Input | undefined, R = unknown> {
+  /** What the tool does and when an agent should call it. Agents read this to pick a tool. */
+  description: string;
+  /** valibot schema or `{ key: schema }` shape of the arguments. Omit it for no arguments. */
+  input?: I;
+  /** Only reads, changes nothing. Agents may call such tools without asking the user. */
+  readOnly?: boolean;
+  handler(event: RequestEvent, input: I extends Input ? Output<I> : undefined): R | Promise<R>;
+}
+/** A tool in `server/tools/` (`server/tools/todos/add.ts` is `todos.add`). */
+export declare function defineTool<R, I extends Input | undefined = undefined>(tool: Tool<I, R>): Tool<I, R>;
+//#endregion

package/dist/runtime/server/tools.js

@@ -0,0 +1,7 @@
+//#region src/runtime/server/tools.ts
+/** A tool in `server/tools/` (`server/tools/todos/add.ts` is `todos.add`). */
+function defineTool(tool) {
+	return tool;
+}
+//#endregion
+export { defineTool };

package/dist/runtime/server/validate.d.ts

@@ -3,8 +3,8 @@ import * as v from "valibot";
 //#region src/runtime/server/validate.d.ts
 type Schema = v.GenericSchema | v.GenericSchemaAsync;
 type Shape = v.ObjectEntriesAsync;
-type Input = Schema | Shape;
-type Output<T extends Input> = T extends Schema ? v.InferOutput<T> : T extends Shape ? v.InferOutput<v.ObjectSchemaAsync<T, undefined>> : never;
+export type Input = Schema | Shape;
+export type Output<T extends Input> = T extends Schema ? v.InferOutput<T> : T extends Shape ? v.InferOutput<v.ObjectSchemaAsync<T, undefined>> : never;
 export type SafeResult<T extends Input> = {
   success: true;
   data: Output<T>;
@@ -14,6 +14,8 @@ export type SafeResult<T extends Input> = {
   data?: undefined;
   issues: v.FlatErrors<undefined>;
 };
+export declare function toSchema(input: Input): Schema;
+export declare function safeValidate<T extends Input>(input: T, data: unknown): Promise<SafeResult<T>>;
 /** Parsed JSON body. Throws a 400 with flattened issues when invalid. */
 export declare const useValidatedBody: <T extends Input>(event: RequestEvent, schema: T) => Promise<Output<T>>;
 /** Query parameters (strings; use `vh.*` to coerce). Throws a 400 when invalid. */

package/dist/runtime/server/validate.js

@@ -48,4 +48,4 @@ const vh = {
 	id: v.pipe(v.string(), v.digits(), v.transform(Number), v.safeInteger(), v.minValue(1))
 };
 //#endregion
-export { useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh };
+export { safeValidate, toSchema, useSafeValidatedBody, useSafeValidatedParams, useSafeValidatedQuery, useValidatedBody, useValidatedParams, useValidatedQuery, vh };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wervt/nuxt",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Nuxt module for apps hosted on wervt: database, live data and runtime setup.",
   "keywords": [
     "drizzle",
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@electric-sql/client": "^1.5.28",
+    "@valibot/to-json-schema": "^1.8.0",
     "aws4fetch": "^1.0.20",
     "evlog": "^2.30.0",
     "postgres": "^3.4.9",