@menapo/forms 0.0.0-stage → 0.1.0

package/dist/vite.js

@@ -0,0 +1,1154 @@
+import { builtinModules, createRequire } from "node:module";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseSync, runnerImport } from "vite";
+//#region ../glue/src/detect.ts
+/**
+* Which framework a module renders with (machine PLAN §5.5), the way vicss
+* decides it: `.vue` and `.svelte` (with `.svelte.js`/`.svelte.ts` rune
+* modules) by extension; JSX by its `@jsxImportSource` pragma, else the
+* project's JSX framework ({@link jsxFrameworkOf}); plain scripts by the
+* plugin's `framework` option, else the framework the root `package.json`
+* depends on, else none (vanilla). Plain data in and out, so it is
+* unit-tested without Vite.
+*
+* vi18n has a detection of its own (its `vite/glue/detect.ts`, by plugin
+* names); it is published, so moving it onto this module waits for its
+* next minor (machine PLAN §11).
+*/
+/** Root dependencies that name a project's framework, the first found winning. */
+const DEPENDENCIES = [
+	["vue", "vue"],
+	["svelte", "svelte"],
+	["solid-js", "solid"],
+	["preact", "preact"],
+	["react", "react"]
+];
+/** `preact`, `solid-js` and `vue` (and their subpaths) by name; any other JSX source takes React's. */
+function jsxFramework(source) {
+	const name = source.split("/")[0];
+	if (name === "preact") return "preact";
+	if (name === "solid-js") return "solid";
+	if (name === "vue") return "vue";
+	return "react";
+}
+/** The framework of module `id` with source `code`. */
+function frameworkOf(id, code, settings) {
+	const file = id.replace(/[?#].*$/, "").toLowerCase();
+	if (file.endsWith(".vue")) return "vue";
+	if (file.endsWith(".svelte") || /\.svelte\.[cm]?[jt]s$/.test(file)) return "svelte";
+	if (/\.[jt]sx$/.test(file)) {
+		const pragma = /@jsxImportSource\s+([^\s*]+)/.exec(code)?.[1];
+		return pragma ? jsxFramework(pragma) : settings.jsx;
+	}
+	return settings.scripts;
+}
+/** The names a `package.json` depends on, if it can be read. */
+function dependencies(root) {
+	const file = join(root, "package.json");
+	if (!existsSync(file)) return void 0;
+	try {
+		const pkg = JSON.parse(readFileSync(file, "utf8"));
+		return /* @__PURE__ */ new Set([...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})]);
+	} catch {
+		return;
+	}
+}
+/** The framework the `package.json` in `root` depends on, if a known one. */
+function rootFramework(root) {
+	const names = dependencies(root);
+	return names && DEPENDENCIES.find(([name]) => names.has(name))?.[1];
+}
+/**
+* JSX frameworks by the names of the Vite plugins that compile them, as
+* vi18n recognises them: a prefix up to a separator, or the exact name.
+*/
+const JSX_PLUGINS = [
+	["react", /^(?:vite:react|@vitejs\/plugin-react)(?:[:/-]|$)/],
+	["preact", /^(?:preact:|vite:preact(?:[:/-]|$)|@preact\/|prefresh(?:[:/-]|$)|preact$)/],
+	["solid", /^(?:solid:|vite-plugin-solid(?:[:/-]|$)|solid-start(?:[:/-]|$)|solid$)/],
+	["vue", /^(?:vite:vue-jsx|@vitejs\/plugin-vue-jsx)(?:[:/-]|$)/]
+];
+/** The one JSX framework whose Vite plugin is in `plugins`; none when there are none or several. */
+function pluginFramework(plugins) {
+	const found = /* @__PURE__ */ new Set();
+	for (const plugin of plugins) {
+		const name = plugin?.name;
+		if (typeof name !== "string") continue;
+		for (const [framework, pattern] of JSX_PLUGINS) if (pattern.test(name)) found.add(framework);
+	}
+	return found.size === 1 ? [...found][0] : void 0;
+}
+/** tsconfig's JSON with comments and trailing commas, as TypeScript reads it. */
+function parseJsonc(text) {
+	let out = "";
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (c === "\"") {
+			const end = /"(?:[^"\\]|\\.)*"/y;
+			end.lastIndex = i;
+			const string = end.exec(text)?.[0] ?? c;
+			out += string;
+			i += string.length - 1;
+		} else if (c === "/" && text[i + 1] === "/") {
+			while (i < text.length && text[i] !== "\n") i++;
+			out += "\n";
+		} else if (c === "/" && text[i + 1] === "*") {
+			const end = text.indexOf("*/", i + 2);
+			i = end < 0 ? text.length : end + 1;
+		} else out += c;
+	}
+	return JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+}
+/** A tsconfig named by `extends` or a reference: a file, a directory's `tsconfig.json`, or a package's. */
+function tsconfigPath(from, name) {
+	const local = name.startsWith(".") || name.startsWith("/");
+	let path;
+	try {
+		path = local ? resolve(dirname(from), name) : createRequire(from).resolve(name);
+	} catch {
+		return;
+	}
+	if (existsSync(path) && statSync(path).isDirectory()) path = join(path, "tsconfig.json");
+	else if (!existsSync(path) && existsSync(`${path}.json`)) path = `${path}.json`;
+	return existsSync(path) ? path : void 0;
+}
+/**
+* `compilerOptions.jsxImportSource` as TypeScript resolves it for `file`:
+* its own, else its `extends`' (the last one first); then, for a solution
+* file (`references`, as create-vite writes), the first referenced project
+* that sets one.
+*/
+function tsconfigJsxSource(file, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(file) || !existsSync(file)) return void 0;
+	seen.add(file);
+	let config;
+	try {
+		config = parseJsonc(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+	const own = config.compilerOptions?.jsxImportSource;
+	if (typeof own === "string") return own;
+	const bases = typeof config.extends === "string" ? [config.extends] : config.extends ?? [];
+	for (const base of [...bases].reverse()) {
+		const path = tsconfigPath(file, base);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+	for (const reference of config.references ?? []) {
+		const path = tsconfigPath(file, reference.path);
+		const found = path && tsconfigJsxSource(path, seen);
+		if (found) return found;
+	}
+}
+/**
+* The framework of JSX without a pragma: the JSX import source the Vite
+* config gives Oxc or esbuild; else the one JSX framework whose Vite plugin
+* is installed (`vite-plugin-solid`, the Preact preset); else the root
+* tsconfig's `jsxImportSource`, through `extends` and `references`; else
+* Preact, Solid or Vue when the root `package.json` depends on it; else React.
+*/
+function jsxFrameworkOf(config, root) {
+	const oxc = config.oxc;
+	const esbuild = config.esbuild;
+	const fromVite = (oxc && oxc.jsx?.importSource) ?? (esbuild && esbuild.jsxImportSource);
+	if (typeof fromVite === "string") return jsxFramework(fromVite);
+	const plugin = pluginFramework(config.plugins ?? []);
+	if (plugin) return plugin;
+	const fromTsconfig = tsconfigJsxSource(join(root, "tsconfig.json"));
+	if (fromTsconfig) return jsxFramework(fromTsconfig);
+	const names = dependencies(root);
+	if (names?.has("preact")) return "preact";
+	if (names?.has("solid-js")) return "solid";
+	if (names?.has("vue") && !names.has("react")) return "vue";
+	return "react";
+}
+//#endregion
+//#region ../glue/src/vite.ts
+/**
+* The build side of the shared glue (machine PLAN §5.1, §5.5): a Vite
+* plugin that resolves a package's hooks (`useMachine` from
+* `@menapo/machine`) per module to that module's framework, so one import
+* works in React, Preact, Vue, Svelte, Solid and plain scripts, and no
+* package has a `/react` or `/vue` entry (repo rule: entries by role).
+*
+* - **Per module:** each module importing a hook gets the hook from
+*   `virtual:<package>/glue/<framework>`, which resolves to the package's
+*   glue module for that framework; the rest of the import stays. Every
+*   form that reaches a hook is rewritten: named imports (string names
+*   too), a namespace import's members, re-exports, `export *` and
+*   `import()`.
+* - **The app's framework:** a glue module and the adapters it uses import
+*   `react`, `vue`… by name. Those imports resolve from the project root, as
+*   the app's own do, so the app's single copy is used wherever the glue
+*   module lives (a workspace package, `node_modules`); one that does not
+*   resolve there fails the build, naming the fix.
+*/
+/**
+* A path as Vite writes ids, with forward slashes on every platform:
+* `fileURLToPath` gives backslashes on Windows, and a prefix test of one
+* against the other never matches.
+*/
+const posix = (path) => path.replace(/\\/g, "/");
+/** Whether `id` is inside one of `dirs`, both compared as Vite writes them. */
+const within = (dirs, id) => dirs.some((dir) => posix(id).startsWith(posix(dir)));
+/** The adapters' own directory: their framework imports resolve from the project root too. */
+const OWN$2 = dirname(fileURLToPath(import.meta.url));
+/** Packages a glue module imports by name: resolved from the project root. */
+const FRAMEWORK_IMPORT = /^(?:react|react-dom|preact|vue|svelte|solid-js)(?:\/|$)/;
+/** The modules the rewrite reads: scripts and framework files, never `?raw` text or an asset's URL. */
+const MODULE = /\.(?:[cm]?[jt]sx?|vue|svelte)(?:\?|$)/;
+const NOT_CODE = /[?&](?:raw|url|inline|worker|sharedworker)(?:[&=]|$)/;
+/** The scripts of a module: the whole of it, or a `.vue`/`.svelte` file's `<script>` blocks. */
+function scripts(code, file) {
+	const framework = /\.(?:vue|svelte)$/.test(file);
+	if (!framework || !code.includes("<script")) return [{
+		offset: 0,
+		source: code,
+		name: framework ? "x.ts" : file
+	}];
+	const out = [];
+	for (const match of code.matchAll(/(<script\b([^>]*)>)([\s\S]*?)<\/script>/g)) {
+		const lang = /\blang\s*=\s*["']([jt]sx?)["']/.exec(match[2])?.[1] ?? "js";
+		out.push({
+			offset: match.index + match[1].length,
+			source: match[3],
+			name: `x.${lang}`
+		});
+	}
+	return out;
+}
+/** Every node below `node`, depth first. */
+function walk$2(node, visit) {
+	if (Array.isArray(node)) for (const child of node) walk$2(child, visit);
+	else if (node && typeof node === "object" && typeof node.type === "string") {
+		visit(node);
+		for (const key of Object.keys(node)) if (key !== "parent") walk$2(node[key], visit);
+	}
+}
+const nameOf = (node) => node.type === "Identifier" ? node.name : String(node.value);
+/** A name as a specifier writes it: bare when it is an identifier, else quoted (`"a-b"`). */
+const spell = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+/**
+* Rewrites every way module `code` reaches `hooks` of `pkg` so they come
+* from `target`; type-only imports and specifiers stay. Replacements keep
+* the lines they replace, so every other position in the module stands.
+* Null when the module reaches no hook.
+*/
+function rewrite(code, file, pkg, hooks, target) {
+	const edits = [];
+	const to = JSON.stringify(target);
+	const from = JSON.stringify(pkg);
+	const lines = (start, end) => "\n".repeat(code.slice(start, end).split("\n").length - 1);
+	for (const { offset, source, name } of scripts(code, file)) {
+		const { program, errors } = parseSync(name, source);
+		if (errors.length) continue;
+		const at = (node) => [offset + node.start, offset + node.end];
+		/** Namespace imports of the package: their hook members are rewritten to `__glue_<hook>`. */
+		const namespaces = /* @__PURE__ */ new Set();
+		/** Where the hooks those members read are imported: before the namespace's import, on its line. */
+		let hidden;
+		let used = false;
+		for (const statement of program.body) if (statement.type === "ImportDeclaration" && statement.source.value === pkg) {
+			if (statement.importKind === "type") continue;
+			const mine = [];
+			const rest = [];
+			let namespace;
+			for (const specifier of statement.specifiers) if (specifier.type === "ImportNamespaceSpecifier") namespace = specifier.local.name;
+			else if (specifier.type === "ImportSpecifier") {
+				const imported = nameOf(specifier.imported);
+				const local = specifier.local.name;
+				const text = imported === local ? local : `${spell(imported)} as ${local}`;
+				if (specifier.importKind !== "type" && hooks.includes(imported)) mine.push(text);
+				else rest.push(specifier.importKind === "type" ? `type ${text}` : text);
+			}
+			if (namespace !== void 0) {
+				namespaces.add(namespace);
+				hidden ??= offset + statement.start;
+			}
+			if (!mine.length) continue;
+			const [start, end] = at(statement);
+			const kept = rest.length ? `import { ${rest.join(", ")} } from ${from}; ` : "";
+			edits.push([
+				start,
+				end,
+				`${kept}import { ${mine.join(", ")} } from ${to};${lines(start, end)}`
+			]);
+		} else if (statement.type === "ExportNamedDeclaration" && statement.source?.value === pkg && statement.exportKind !== "type") {
+			const mine = [];
+			const rest = [];
+			for (const specifier of statement.specifiers) {
+				const local = nameOf(specifier.local);
+				const exported = nameOf(specifier.exported);
+				const text = local === exported ? spell(local) : `${spell(local)} as ${spell(exported)}`;
+				if (specifier.exportKind !== "type" && hooks.includes(local)) mine.push(text);
+				else rest.push(specifier.exportKind === "type" ? `type ${text}` : text);
+			}
+			if (!mine.length) continue;
+			const [start, end] = at(statement);
+			const kept = rest.length ? `export { ${rest.join(", ")} } from ${from}; ` : "";
+			edits.push([
+				start,
+				end,
+				`${kept}export { ${mine.join(", ")} } from ${to};${lines(start, end)}`
+			]);
+		} else if (statement.type === "ExportAllDeclaration" && statement.source.value === pkg && !statement.exported && statement.exportKind !== "type") {
+			const [, end] = at(statement);
+			edits.push([
+				end,
+				end,
+				` export { ${hooks.join(", ")} } from ${to};`
+			]);
+		}
+		walk$2(program.body, (node) => {
+			if (node.type === "ImportExpression" && node.source.type === "Literal" && node.source.value === pkg) {
+				const [start, end] = at(node);
+				edits.push([
+					start,
+					end,
+					`Promise.all([import(${from}), import(${to})]).then(([m, g]) => ({ ...m, ...g }))`
+				]);
+			} else if (node.type === "MemberExpression" && node.object.type === "Identifier" && namespaces.has(node.object.name)) {
+				const key = node.computed ? node.property.type === "Literal" && typeof node.property.value === "string" ? node.property.value : void 0 : nameOf(node.property);
+				if (key === void 0 || !hooks.includes(key)) return;
+				const [start, end] = at(node);
+				edits.push([
+					start,
+					end,
+					`__glue_${key}`
+				]);
+				used = true;
+			}
+		});
+		if (used && hidden !== void 0) {
+			const names = hooks.map((hook) => `${hook} as __glue_${hook}`).join(", ");
+			edits.push([
+				hidden,
+				hidden,
+				`import { ${names} } from ${to}; `
+			]);
+		}
+	}
+	if (!edits.length) return null;
+	let out = code;
+	for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0] || b[1] - a[1])) out = out.slice(0, start) + text + out.slice(end);
+	return out;
+}
+/** The plugin resolving `options.hooks` per framework. */
+function gluePlugin(options) {
+	const prefix = `virtual:${options.package}/glue/`;
+	const dirs = [OWN$2, ...options.dirs].map(posix);
+	let settings = {
+		scripts: "vanilla",
+		jsx: "react"
+	};
+	let root = process.cwd();
+	return {
+		name: options.name,
+		enforce: "pre",
+		configResolved(config) {
+			root = config.root;
+			settings = {
+				scripts: options.framework ?? rootFramework(root) ?? "vanilla",
+				jsx: jsxFrameworkOf(config, root)
+			};
+		},
+		async resolveId(source, importer) {
+			if (source.startsWith(prefix)) return posix(options.module(source.slice(prefix.length)));
+			if (importer && FRAMEWORK_IMPORT.test(source) && within(dirs, importer)) {
+				const found = await this.resolve(source, join(root, "index.html"), { skipSelf: true });
+				if (found) return found;
+				this.error(`[${options.name}] the ${options.package} glue imports "${source}", which does not resolve from the project root (${root}): install it there, or tell the plugin the framework (its \`framework\` option for plain scripts, a \`@jsxImportSource\` pragma or tsconfig's \`jsxImportSource\` for JSX).`);
+			}
+			return null;
+		},
+		transform: {
+			filter: {
+				id: {
+					include: MODULE,
+					exclude: NOT_CODE
+				},
+				code: options.package
+			},
+			handler(code, id) {
+				if (id.startsWith("\0") || within(dirs, id)) return null;
+				const framework = frameworkOf(id, code, settings);
+				const out = rewrite(code, posix(id).replace(/[?#].*$/, ""), options.package, options.hooks, prefix + framework);
+				return out === null ? null : {
+					code: out,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region ../glue/src/devtools.ts
+/** A panel: an iframe of the page served at `<base><path>`. */
+const dockEntry = (panel, base, path) => ({
+	...panel,
+	category: "framework",
+	type: "iframe",
+	url: base + path
+});
+/** Serves `page()` at `<anything>/<path>` while `on()` holds; other requests pass. */
+function serveDock(server, path, on, page) {
+	server.middlewares.use((req, res, next) => {
+		const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
+		if (!on() || req.method !== "GET" || !pathname.endsWith(`/${path}`)) return next();
+		res.setHeader("content-type", "text/html; charset=utf-8");
+		res.setHeader("cache-control", "no-store");
+		res.end(page());
+	});
+}
+/**
+* The page's bridge as the panel finds it: the global `name` on the nearest
+* ancestor window that has it (Vite DevTools may nest the iframe). A panel
+* page runs from its own source text, so it is handed this function's
+* source (`${findBridge}`) rather than importing it.
+*/
+function findBridge(name) {
+	for (let w = window.parent;; w = w.parent) {
+		try {
+			const found = w[name];
+			if (found) return found;
+		} catch {}
+		if (w === w.parent) return void 0;
+	}
+}
+//#endregion
+//#region src/vite/devtools.ts
+/**
+* `forms:devtools` (D18, M6): a panel in the Vite DevTools dock listing the
+* forms rendered on the page with their values, the errors shown, what is
+* touched and dirty, and the last submits with their timings and errors,
+* on the shared dock plumbing (`@menapo/glue/devtools`), as query's panel.
+* Vite DevTools calls `devtools.setup` only when the user turned it on, so
+* until then this plugin does nothing; a build never runs it.
+*/
+const OWN$1 = posix(fileURLToPath(new URL("..", import.meta.url)));
+const DOCK_PATH = "__forms/dock";
+const PAGE_ID = "virtual:forms/devtools";
+const BRIDGE = "__formsDevtools";
+/** The page's half, sent as source text: watches the page's forms through `inspect`. */
+function page(inspect, global) {
+	const listeners = /* @__PURE__ */ new Set();
+	const live = /* @__PURE__ */ new Set();
+	const recent = [];
+	const text = (error) => error === void 0 ? void 0 : String(error.message ?? error);
+	const json = (value) => JSON.stringify(value, (_, v) => typeof Blob !== "undefined" && v instanceof Blob ? `[${v.type || "file"}, ${v.size} B]` : v);
+	inspect((event) => {
+		const instance = event.instance;
+		if (event.kind === "gone") live.delete(instance);
+		else live.add(instance);
+		if (event.kind === "submit") {
+			recent.unshift({
+				form: instance.F.n,
+				ms: Math.round(event.ms),
+				error: text(event.error)
+			});
+			if (recent.length > 50) recent.pop();
+		}
+		for (const listener of listeners) listener();
+	});
+	globalThis[global] = {
+		rows: () => [...live].map((i) => ({
+			form: i.F.n,
+			id: i.id,
+			values: json(i.v) ?? "{}",
+			errors: [...i.r.entries()].filter(([, r]) => r.e !== void 0).map(([path, r]) => ({
+				path,
+				message: r.e
+			})),
+			touched: [...i.r.entries()].filter(([, r]) => r.t).map(([path]) => path),
+			dirty: [...i.dp],
+			pending: i.pending,
+			error: text(i.error)
+		})),
+		recent: () => recent,
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		}
+	};
+}
+const pageModule = () => `import { inspect } from "@menapo/forms";\n(${page.toString()})(inspect, ${JSON.stringify(BRIDGE)});\n`;
+/** The dock's document: each form, then the recent submits. */
+const dockPage = () => `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><title>Forms</title>
+<style>
+body{font:13px system-ui,sans-serif;margin:0;color:CanvasText;background:Canvas}
+table{border-collapse:collapse;width:100%}th,td{text-align:left;vertical-align:top;padding:4px 8px;border-bottom:1px solid #8884}
+th{position:sticky;top:0;background:Canvas}code{font:12px ui-monospace,monospace;white-space:pre-wrap}.error{color:#c33}
+h2{font-size:13px;margin:12px 8px 4px}
+</style></head><body>
+<table><thead><tr><th scope="col">Form</th><th scope="col">Values</th><th scope="col">Errors shown</th><th scope="col">Touched</th><th scope="col">Dirty</th><th scope="col">State</th></tr></thead><tbody id="rows"></tbody></table>
+<p id="none" hidden>No form is rendered.</p>
+<h2>Recent submits</h2>
+<table><thead><tr><th scope="col">Form</th><th scope="col">Time</th><th scope="col">Result</th></tr></thead><tbody id="recent"></tbody></table>
+<script type="module">
+const findBridge = ${findBridge.toString()};
+const bridge = findBridge(${JSON.stringify(BRIDGE)});
+const esc = (s) => String(s).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+function render() {
+  const rows = bridge ? bridge.rows() : [];
+  document.getElementById("none").hidden = rows.length > 0;
+  document.getElementById("rows").innerHTML = rows.map((r) => '<tr><td><code>' + esc(r.form) + '</code></td><td><code>' + esc(r.values) + '</code></td><td class="error">' + r.errors.map((e) => esc(e.path) + ': ' + esc(e.message)).join('<br>') + '</td><td>' + esc(r.touched.join(', ')) + '</td><td>' + esc(r.dirty.join(', ')) + '</td><td>' + (r.pending ? 'submitting' : r.error ? '<span class="error">' + esc(r.error) + '</span>' : 'idle') + '</td></tr>').join("");
+  document.getElementById("recent").innerHTML = (bridge ? bridge.recent() : []).map((s) => '<tr><td><code>' + esc(s.form) + '</code></td><td>' + s.ms + ' ms</td><td class="' + (s.error ? 'error' : '') + '">' + (s.error ? esc(s.error) : 'ok') + '</td></tr>').join("");
+}
+if (bridge) { bridge.subscribe(render); }
+render();
+<\/script></body></html>`;
+const formsDockEntry = (base) => dockEntry({
+	id: "forms",
+	title: "Forms",
+	icon: "ph:textbox-duotone"
+}, base, DOCK_PATH);
+const RESOLVED = "\0" + PAGE_ID;
+function devtoolsPlugin() {
+	let on = false;
+	return {
+		name: "forms:devtools",
+		apply: "serve",
+		devtools: { setup(context) {
+			on = true;
+			context.docks.register(formsDockEntry(context.viteConfig.base));
+		} },
+		configureServer(server) {
+			serveDock(server, DOCK_PATH, () => on, dockPage);
+		},
+		resolveId: {
+			filter: { id: /^virtual:forms\/devtools$/ },
+			handler: (id) => "\0" + id
+		},
+		load: {
+			filter: { id: /^\0virtual:forms\/devtools$/ },
+			handler: (id) => id === RESOLVED ? {
+				code: pageModule(),
+				moduleType: "js"
+			} : null
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.[cm]?[jt]sx?(?:\?|$)/,
+					exclude: /\/node_modules\//
+				},
+				code: "@menapo/forms"
+			},
+			handler(code, id) {
+				if (!on || this.environment.config.consumer !== "client" || posix(id).startsWith(OWN$1)) return null;
+				return {
+					code: `${code}\nimport ${JSON.stringify(PAGE_ID)};\n`,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/vite/names.ts
+/**
+* Definitions as the plugin rewrites them (D1, D4, D13, D17): each
+* top-level `const x = form(…)` is pointed at the factory of its kind,
+* route or function, and gets a hidden last argument, `{ n:
+* "src/forms.ts#x", s, f, c, a }`: its name for DevTools and errors, a route
+* form's browser schema (a `virtual:` module, D4), the field spec, the
+* checks module when its options have `checks`, and the array module when
+* its spec or its defaults have an array (D14). A call that isn't a
+* top-level declaration (a new form each render) is reported. Plain data
+* in and out, so it is unit-tested without Vite.
+*/
+const ROUTE = /^(POST|PUT|PATCH|DELETE) (\/\S*)$/;
+/** The schema module of a route: `virtual:@menapo/forms/schema/post/orgs/:slug`. */
+const SCHEMA_PREFIX = "virtual:@menapo/forms/schema/";
+const schemaId = (route) => {
+	const [, method, pattern] = ROUTE.exec(route);
+	return SCHEMA_PREFIX + method.toLowerCase() + pattern;
+};
+function walk$1(node, visit) {
+	if (Array.isArray(node)) for (const child of node) walk$1(child, visit);
+	else if (node && typeof node === "object" && typeof node.type === "string") {
+		visit(node);
+		for (const key of Object.keys(node)) if (key !== "parent") walk$1(node[key], visit);
+	}
+}
+/** Rewrites module `code`; with no options, only finds its definitions. */
+function annotate(code, file, options) {
+	const none = {
+		code: null,
+		definitions: [],
+		warnings: []
+	};
+	const { program, errors } = parseSync(file, code);
+	if (errors.length) return none;
+	const local = /* @__PURE__ */ new Set();
+	for (const statement of program.body) if (statement.type === "ImportDeclaration" && statement.source.value === "@menapo/forms" && statement.importKind !== "type") {
+		for (const s of statement.specifiers) if (s.type === "ImportSpecifier" && s.importKind !== "type" && (s.imported.type === "Identifier" ? s.imported.name : s.imported.value) === "form") local.add(s.local.name);
+	}
+	if (!local.size) return none;
+	const named = /* @__PURE__ */ new Set();
+	const edits = [];
+	const found = [];
+	const imports = /* @__PURE__ */ new Map();
+	let schemas = 0;
+	for (const statement of program.body) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type !== "VariableDeclaration") continue;
+		for (const declarator of declaration.declarations) {
+			const call = declarator.init;
+			if (call?.type !== "CallExpression" || call.callee.type !== "Identifier" || !local.has(call.callee.name) || declarator.id.type !== "Identifier" || !call.arguments.length || call.arguments.some((a) => a.type === "SpreadElement")) continue;
+			named.add(call);
+			const first = call.arguments[0];
+			const route = first.type === "Literal" && typeof first.value === "string" && ROUTE.test(first.value) ? first.value : void 0;
+			const definition = route ? {
+				name: declarator.id.name,
+				kind: "route",
+				route
+			} : {
+				name: declarator.id.name,
+				kind: "fn"
+			};
+			found.push(definition);
+			if (!options) continue;
+			const at = route ? 1 : 2;
+			const given = call.arguments[at];
+			const option = (name) => given?.type === "ObjectExpression" ? given.properties.find((p) => p.type === "Property" && !p.computed && (p.key.type === "Identifier" && p.key.name === name || p.key.type === "Literal" && p.key.value === name)) : void 0;
+			const checks = option("checks") !== void 0;
+			let arrays = false;
+			walk$1(option("defaults"), (node) => void (arrays ||= node.type === "ArrayExpression"));
+			const parts = [`n: ${JSON.stringify(`${file}#${declarator.id.name}`)}`];
+			if (route) {
+				const id = `__forms_schema${schemas++}`;
+				imports.set(id, `default from ${JSON.stringify(schemaId(route))}`);
+				parts.push(`s: ${id}`);
+			}
+			const spec = options.spec(definition);
+			if (spec && Object.keys(spec).length) parts.push(`f: ${JSON.stringify(spec)}`);
+			if (arrays || Object.values(spec ?? {}).some((field) => field.t === "array")) {
+				imports.set("__forms_array", `{ arrayField as __forms_array } from ${JSON.stringify(options.modules.array)}`);
+				parts.push("a: __forms_array");
+			}
+			if (checks) {
+				imports.set("__forms_checks", `{ checks as __forms_checks } from ${JSON.stringify(options.modules.checks)}`);
+				parts.push("c: __forms_checks");
+			}
+			const factory = route ? "__forms_routeForm" : "__forms_fnForm";
+			imports.set(factory, `{ ${route ? "routeForm" : "fnForm"} as ${factory} } from ${JSON.stringify(route ? options.modules.route : options.modules.fn)}`);
+			edits.push([
+				call.callee.start,
+				call.callee.end,
+				factory
+			]);
+			const last = call.arguments.at(-1);
+			const missing = at + 1 - call.arguments.length;
+			edits.push([
+				last.end,
+				last.end,
+				`${", undefined".repeat(Math.max(0, missing))}, { ${parts.join(", ")} }`
+			]);
+		}
+	}
+	const warnings = [];
+	walk$1(program.body, (node) => {
+		if (node.type === "CallExpression" && node.callee.type === "Identifier" && local.has(node.callee.name) && !named.has(node)) {
+			const line = code.slice(0, node.start).split("\n").length;
+			warnings.push(`[forms:INLINE_FORM] ${file}:${line}: form() inside a component makes a new form each render; export it from a module (export const x = form(…)) and import it.`);
+		}
+	});
+	if (!options || !edits.length) return {
+		code: null,
+		definitions: found,
+		warnings
+	};
+	const at = program.body.findLast((s) => s.type === "ImportDeclaration").end;
+	const lines = [...imports.entries()].map(([id, spec]) => spec.startsWith("default ") ? `import ${id} ${spec.slice(8)};` : `import ${spec};`);
+	edits.push([
+		at,
+		at,
+		lines.join(" ")
+	]);
+	let out = code;
+	for (const [start, end, text] of edits.sort((a, b) => b[0] - a[0] || b[1] - a[1])) out = out.slice(0, start) + text + out.slice(end);
+	return {
+		code: out,
+		definitions: found,
+		warnings
+	};
+}
+//#endregion
+//#region src/vite/slice.ts
+/**
+* The schema slice (D4, spike S1): the browser's copy of an operation's
+* input schema, cut from the module that defines the operation. It keeps
+* the `input` expression and the top-level declarations it reads,
+* transitively, with their imports; `run`, `meta` and whatever only they
+* read stay on the server. A slice is refused, naming the fix, when it
+* would read a binding that isn't a top-level declaration or import, or
+* import a module the browser can't or mustn't load (Node's built-ins, the
+* server side of `@menapo/api`, Hono, a `server/` directory or a
+* `.server.` module, or a local module that imports one of those).
+*
+* `toStandardJsonSchema(x)` from `@valibot/to-json-schema` is cut to `x`:
+* the browser validates and never converts, so the converter stays out of
+* its bundle. Plain data in and out, so it is unit-tested without Vite.
+*/
+/** Bare imports the browser must not load: the server side. */
+const SERVER = /^(?:node:|hono(?:\/|$)|@hono\/|@menapo\/api(?!\/client)(?:\/|$)|@menapo\/query\/server)/;
+const BUILTIN = new Set(builtinModules);
+/** Local modules that say they are the server's. */
+const SERVER_FILE = /(?:^|\/)server\/|\.server\.[cm]?[jt]sx?$/;
+const EXTENSIONS = [
+	"",
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mts",
+	".mjs",
+	"/index.ts",
+	"/index.js"
+];
+var SliceError = class extends Error {};
+/** Every node below `node`, depth first, skipping TypeScript's types (they read no values). */
+function walk(node, visit, parent, key = "") {
+	if (Array.isArray(node)) {
+		for (const child of node) walk(child, visit, parent, key);
+		return;
+	}
+	if (!node || typeof node !== "object" || typeof node.type !== "string") return;
+	const n = node;
+	if (visit(n, parent, key) === false) return;
+	if (n.type.startsWith("TS")) {
+		const expression = n.expression;
+		if (expression) walk(expression, visit, n, "expression");
+		return;
+	}
+	for (const k of Object.keys(n)) {
+		if (k === "parent" || k === "typeAnnotation" || k === "returnType" || k === "typeParameters" || k === "typeArguments") continue;
+		walk(n[k], visit, n, k);
+	}
+}
+/** Names a pattern binds: `a`, `{ a, b: c }`, `[d, ...e]`. */
+function bound(pattern, out) {
+	if (!pattern) return;
+	switch (pattern.type) {
+		case "Identifier":
+			out.add(pattern.name);
+			break;
+		case "ObjectPattern":
+			for (const p of pattern.properties) bound(p.type === "RestElement" ? p.argument : p.value, out);
+			break;
+		case "ArrayPattern":
+			for (const e of pattern.elements) bound(e, out);
+			break;
+		case "RestElement":
+			bound(pattern.argument, out);
+			break;
+		case "AssignmentPattern": bound(pattern.left, out);
+	}
+}
+/** The free names `node` reads (approximately: names bound in nested functions are left out). */
+function reads(node) {
+	const local = /* @__PURE__ */ new Set();
+	walk(node, (n) => {
+		if (n.type === "ArrowFunctionExpression" || n.type === "FunctionExpression" || n.type === "FunctionDeclaration") {
+			for (const param of n.params) bound(param, local);
+			if (n.type !== "ArrowFunctionExpression" && n.id) local.add(n.id.name);
+		} else if (n.type === "VariableDeclarator") bound(n.id, local);
+		else if (n.type === "CatchClause") bound(n.param, local);
+	});
+	const out = /* @__PURE__ */ new Set();
+	walk(node, (n, parent, key) => {
+		if (n.type !== "Identifier") return;
+		if (parent?.type === "MemberExpression" && key === "property" && !parent.computed) return;
+		if ((parent?.type === "Property" || parent?.type === "MethodDefinition" || parent?.type === "PropertyDefinition") && key === "key" && !parent.computed) return;
+		if (parent?.type === "LabeledStatement" || parent?.type === "BreakStatement" || parent?.type === "ContinueStatement") return;
+		if (!local.has(n.name)) out.add(n.name);
+	});
+	return out;
+}
+/** A local module's file, as Node or Vite would find it. */
+function resolveLocal(from, source) {
+	const base = resolve(dirname(from), source);
+	for (const ext of EXTENSIONS) if (existsSync(base + ext) && statSync(base + ext).isFile()) return base + ext;
+}
+/** Why `source`, imported from `from`, can't reach the browser; undefined when it can. */
+function serverOnly(from, source, seen) {
+	if (SERVER.test(source) || BUILTIN.has(source)) return source;
+	if (!source.startsWith(".") && !source.startsWith("/")) return void 0;
+	if (SERVER_FILE.test(source)) return source;
+	const file = resolveLocal(from, source);
+	if (!file || seen.has(file)) return void 0;
+	seen.add(file);
+	if (SERVER_FILE.test(file)) return source;
+	const { program, errors } = parseSync(file, readFileSync(file, "utf8"));
+	if (errors.length) return void 0;
+	for (const statement of program.body) {
+		const next = statement.type === "ImportDeclaration" && statement.importKind !== "type" || (statement.type === "ExportNamedDeclaration" || statement.type === "ExportAllDeclaration") && statement.source && statement.exportKind !== "type" ? statement.source.value : void 0;
+		if (next === void 0) continue;
+		const why = serverOnly(file, next, seen);
+		if (why) return `${source}, which imports ${why}`;
+	}
+}
+const GLOBALS = new Set(Object.getOwnPropertyNames(globalThis).concat([
+	"undefined",
+	"NaN",
+	"Infinity",
+	"arguments"
+]));
+/**
+* The browser module for the expression at `[start, end)` of `file`: its
+* declarations and imports, and `export default` the expression.
+*/
+function slice(code, file, start, end, options) {
+	const { program, errors } = parseSync(file, code);
+	if (errors.length) throw new SliceError(`[forms:SCHEMA_SLICE] ${options.label}: ${file} doesn't parse.`);
+	const bindings = /* @__PURE__ */ new Map();
+	/** Import specifiers by local name: the statement's source and the imported name (`*`, `default`). */
+	const imports = /* @__PURE__ */ new Map();
+	let converter;
+	for (const raw of program.body) {
+		const statement = (raw.type === "ExportNamedDeclaration" || raw.type === "ExportDefaultDeclaration") && raw.declaration ? raw.declaration : raw;
+		if (statement.type === "ImportDeclaration") {
+			if (statement.importKind === "type") continue;
+			for (const s of statement.specifiers) {
+				if (s.type === "ImportSpecifier" && s.importKind === "type") continue;
+				const imported = s.type === "ImportNamespaceSpecifier" ? "*" : s.type === "ImportDefaultSpecifier" ? "default" : s.imported.type === "Identifier" ? s.imported.name : String(s.imported.value);
+				imports.set(s.local.name, {
+					source: statement.source.value,
+					imported
+				});
+				if (statement.source.value === "@valibot/to-json-schema" && imported === "toStandardJsonSchema") converter = s.local.name;
+			}
+		} else if (statement.type === "VariableDeclaration") for (const d of statement.declarations) {
+			const names = /* @__PURE__ */ new Set();
+			bound(d.id, names);
+			for (const name of names) bindings.set(name, {
+				statement: raw,
+				node: d
+			});
+		}
+		else if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && statement.id) bindings.set(statement.id.name, {
+			statement: raw,
+			node: statement
+		});
+	}
+	/** The node of the expression. */
+	let target;
+	walk(program.body, (n) => {
+		if (target) return false;
+		if (n.start === start && n.end === end) {
+			target = n;
+			return false;
+		}
+		return n.start <= start && n.end >= end;
+	});
+	if (!target) throw new SliceError(`[forms:SCHEMA_SLICE] ${options.label}: no expression at ${file}:${start}.`);
+	const kept = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Map();
+	const via = /* @__PURE__ */ new Map();
+	const queue = [...reads(target)].map((name) => [name, void 0]);
+	const seen = /* @__PURE__ */ new Set();
+	while (queue.length) {
+		const [name, from] = queue.shift();
+		if (seen.has(name)) continue;
+		seen.add(name);
+		if (from) via.set(name, from);
+		const chain = () => {
+			const steps = [];
+			for (let at = name; at; at = via.get(at)) steps.unshift(at);
+			return steps.length > 1 ? `reads ${steps[0]}, which ${steps.slice(1).map((s) => `reads ${s}`).join(", which ")}` : `reads ${steps[0]}`;
+		};
+		const imported = imports.get(name);
+		if (imported) {
+			if (name === converter) continue;
+			const why = serverOnly(file, imported.source, /* @__PURE__ */ new Set());
+			if (why) throw new SliceError(`[forms:SCHEMA_SLICE] ${options.label}: the input ${chain()} from ${why}, and the browser can't load that. Move the schema into a module that imports only your schema library (api/<name>.schema.ts) and import it in both places.`);
+			used.set(name, imported);
+			continue;
+		}
+		const binding = bindings.get(name);
+		if (!binding) {
+			if (GLOBALS.has(name)) continue;
+			throw new SliceError(`[forms:SCHEMA_SLICE] ${options.label}: the input ${chain()}, which isn't a top-level declaration or import of ${file}. Declare it at the top of the module, or move the schema into a module of its own and import it.`);
+		}
+		let declarators = kept.get(binding.statement);
+		if (!declarators) kept.set(binding.statement, declarators = /* @__PURE__ */ new Set());
+		declarators.add(binding.node);
+		const read = binding.node.type === "VariableDeclarator" ? binding.node.init ? reads(binding.node.init) : /* @__PURE__ */ new Set() : reads(binding.node);
+		for (const next of read) if (!seen.has(next)) queue.push([next, name]);
+	}
+	/** `code[node]` with `toStandardJsonSchema(x)` cut to `x`. */
+	const text = (node) => {
+		const edits = [];
+		if (converter) walk(node, (n) => {
+			if (n.type === "CallExpression" && n.callee.type === "Identifier" && n.callee.name === converter && n.arguments[0]) {
+				const arg = n.arguments[0];
+				edits.push([
+					n.start,
+					n.end,
+					`(${text(arg)})`
+				]);
+				return false;
+			}
+		});
+		let out = "";
+		let at = node.start;
+		for (const [s, e, t] of edits.sort((a, b) => a[0] - b[0])) {
+			out += code.slice(at, s) + t;
+			at = e;
+		}
+		return out + code.slice(at, node.end);
+	};
+	const lines = [];
+	const bySource = /* @__PURE__ */ new Map();
+	for (const [local, { source, imported }] of used) {
+		const spec = source.startsWith(".") ? resolveLocal(file, source) ?? resolve(dirname(file), source) : source;
+		if (imported === "*") lines.push(`import * as ${local} from ${JSON.stringify(spec)};`);
+		else if (imported === "default") lines.push(`import ${local} from ${JSON.stringify(spec)};`);
+		else {
+			const list = bySource.get(spec) ?? [];
+			const name = /^[A-Za-z_$][\w$]*$/.test(imported) ? imported : JSON.stringify(imported);
+			list.push(imported === local ? local : `${name} as ${local}`);
+			bySource.set(spec, list);
+		}
+	}
+	for (const [spec, list] of bySource) lines.push(`import { ${list.join(", ")} } from ${JSON.stringify(spec)};`);
+	for (const raw of program.body) {
+		const declarators = kept.get(raw);
+		if (!declarators) continue;
+		const statement = (raw.type === "ExportNamedDeclaration" || raw.type === "ExportDefaultDeclaration") && raw.declaration ? raw.declaration : raw;
+		if (statement.type === "VariableDeclaration") lines.push(`${statement.kind} ${statement.declarations.filter((d) => declarators.has(d)).map((d) => text(d)).join(", ")};`);
+		else lines.push(text(statement));
+	}
+	lines.push(options.as ? `const ${options.as} = ${text(target)};` : `export default ${text(target)};`);
+	return lines.join("\n") + "\n";
+}
+//#endregion
+//#region src/vite/spec.ts
+const TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"array",
+	"object"
+]);
+/** The one non-null type of a property: `["string", "null"]` and `anyOf` alike. */
+function typeOf(schema) {
+	const t = schema.type;
+	if (typeof t === "string") return {
+		type: t,
+		schema
+	};
+	if (Array.isArray(t)) return {
+		type: t.find((x) => x !== "null"),
+		schema
+	};
+	const one = (schema.anyOf ?? schema.oneOf)?.filter((o) => o.type !== "null");
+	if (one?.length === 1) return typeOf(one[0]);
+	if (Array.isArray(schema.enum) && schema.enum.every((x) => typeof x === "string")) return {
+		type: "string",
+		schema
+	};
+	return {
+		type: void 0,
+		schema
+	};
+}
+function object(schema, path, out) {
+	const properties = schema.properties ?? {};
+	const required = new Set(schema.required ?? []);
+	for (const [key, property] of Object.entries(properties)) field(property, path ? `${path}.${key}` : key, required.has(key), out);
+}
+function field(property, path, required, out) {
+	const { type, schema } = typeOf(property);
+	if (type === "object") {
+		object(schema, path, out);
+		return;
+	}
+	const spec = {};
+	if (type && TYPES.has(type)) spec.t = type;
+	if (required) spec.r = 1;
+	if (typeof schema.minLength === "number") spec.mn = schema.minLength;
+	if (typeof schema.maxLength === "number") spec.mx = schema.maxLength;
+	if (typeof schema.minimum === "number") spec.lo = schema.minimum;
+	if (typeof schema.maximum === "number") spec.hi = schema.maximum;
+	const description = property.description ?? schema.description;
+	if (typeof description === "string") spec.d = description;
+	out[path] = spec;
+	if (type === "array" && schema.items && typeof schema.items === "object") field(schema.items, `${path}.*`, false, out);
+}
+/** The spec of an input's JSON Schema, with its upload fields. */
+function specOf(input, files) {
+	const out = {};
+	if (input) object(input, "", out);
+	for (const [name, limits] of Object.entries(files ?? {})) out[name] = {
+		t: "file",
+		r: 1,
+		...limits.types && { a: limits.types.join(",") }
+	};
+	return out;
+}
+//#endregion
+//#region src/vite/index.ts
+/**
+* `@menapo/forms/vite` (PLAN §6.2): resolves `useForm` per framework
+* through the shared glue (G3), points each definition at the factory of
+* its kind with its name and field spec (D17, D13), emits a route form's
+* browser schema as a slice of the operation's own module (D4), read from
+* api's plugin (`menapo:api`, api D32), and adds the DevTools panel (D18).
+* The only entry that imports from the build side.
+*/
+const EXT = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
+const ROOT = new URL(EXT === ".ts" ? "../" : "./", import.meta.url);
+const file = (path) => posix(fileURLToPath(new URL(path + EXT, ROOT)));
+const GLUE = posix(fileURLToPath(new URL("glue/", ROOT)));
+const MODULES = {
+	fn: file("factories/fn"),
+	route: file("factories/route"),
+	checks: EXT === ".ts" ? file("checks/index") : file("checks"),
+	array: EXT === ".ts" ? file("array/index") : file("array")
+};
+const FILES = file("route/files");
+const OWN = posix(fileURLToPath(ROOT));
+const SCRIPT = /\.[cm]?[jt]sx?(?:\?|$)/;
+/** JSON Schema as `~standard.jsonSchema` gives it; transforms ignored (S5, api's `errorMode`). */
+const JSON_OPTIONS = {
+	target: "draft-2020-12",
+	libraryOptions: { errorMode: "ignore" }
+};
+/** A function form's spec, from its schema's Standard JSON Schema form (S5). */
+function fnSpec(definition) {
+	const convert = (definition?.s)?.["~standard"]?.jsonSchema?.input;
+	if (!convert) return void 0;
+	try {
+		return specOf(convert(JSON_OPTIONS));
+	} catch {
+		return;
+	}
+}
+/** `plugins: [forms()]` in a Vite config, beside api's and query's. */
+function forms(options = {}) {
+	let config;
+	let api;
+	let operations;
+	const warned = /* @__PURE__ */ new Set();
+	const ops = () => operations ??= (async () => {
+		const map = /* @__PURE__ */ new Map();
+		for (const op of await api?.operations().catch(() => []) ?? []) map.set(`${op.method.toUpperCase()} ${op.pattern}`, op);
+		return map;
+	})();
+	return [
+		{
+			name: "forms:names",
+			config: () => ({ optimizeDeps: { exclude: ["@menapo/forms", "@menapo/forms/server"] } }),
+			configEnvironment(name, environment) {
+				return (environment.consumer ?? (name === "client" ? "client" : "server")) === "server" ? { resolve: { noExternal: ["@menapo/forms"] } } : void 0;
+			},
+			configResolved(resolved) {
+				config = resolved;
+				api = resolved.plugins.find((p) => p.name === "menapo:api")?.api;
+			},
+			resolveId: {
+				filter: { id: /^virtual:@menapo\/forms\/schema\// },
+				handler: (id) => `\0${id}`
+			},
+			load: {
+				filter: { id: /^\0virtual:@menapo\/forms\/schema\// },
+				async handler(id) {
+					const rest = id.slice(30);
+					const slash = rest.indexOf("/");
+					const route = `${rest.slice(0, slash).toUpperCase()} ${rest.slice(slash)}`;
+					const op = (await ops()).get(route);
+					const say = (message) => {
+						if (!warned.has(message)) this.warn(message);
+						warned.add(message);
+					};
+					let input = "undefined";
+					let body = "";
+					if (!api) say(`[forms:NO_API_PLUGIN] form("${route}") validates only on the server: add api() from "@menapo/api/vite" to vite.config.ts, before forms(), so the browser runs the operation's own schema.`);
+					else if (!op) this.error(`[forms:NO_OPERATION] form("${route}"): the app has no ${route} operation.`);
+					else if (op.source) try {
+						body = slice(readFileSync(op.source.file, "utf8"), op.source.file, op.source.start, op.source.end, {
+							label: `form("${route}")`,
+							as: "__forms_input"
+						});
+						input = "__forms_input";
+					} catch (error) {
+						if (error instanceof SliceError) this.error(error.message);
+						throw error;
+					}
+					else if (op.input) say(`[forms:NO_SCHEMA_SOURCE] form("${route}") validates only on the server: write its input inline in defineApi({ "${op.pattern}": { ${op.method}: { input } } }), so the plugin finds it.`);
+					if (op?.files && Object.keys(op.files).length) return {
+						code: `${body}import { withFiles } from ${JSON.stringify(FILES)};\nexport default withFiles(${input}, ${JSON.stringify(op.files)});\n`,
+						moduleType: "ts"
+					};
+					return {
+						code: `${body}export default ${input};\n`,
+						moduleType: "ts"
+					};
+				}
+			},
+			transform: {
+				filter: {
+					id: {
+						include: SCRIPT,
+						exclude: /\/node_modules\//
+					},
+					code: "@menapo/forms"
+				},
+				async handler(code, id) {
+					if (id.startsWith("\0") || within([OWN], id)) return null;
+					const path = posix(relative(config.root, id.replace(/[?#].*$/, "")));
+					const map = await ops();
+					let module;
+					const loaded = /* @__PURE__ */ new Map();
+					if (/\bform\(\s*[^"'`\s]/.test(code)) try {
+						module = (await runnerImport(id.replace(/[?#].*$/, ""), {
+							root: config.root,
+							configFile: false,
+							logLevel: "silent"
+						})).module;
+					} catch {
+						module = void 0;
+					}
+					const spec = (definition) => {
+						if (definition.kind === "route") {
+							const op = map.get(definition.route);
+							return op && specOf(op.input, op.files);
+						}
+						if (!loaded.has(definition.name)) loaded.set(definition.name, fnSpec(module?.[definition.name]));
+						return loaded.get(definition.name);
+					};
+					const out = annotate(code, path, {
+						spec,
+						modules: MODULES
+					});
+					for (const warning of out.warnings) this.warn(warning);
+					return out.code === null ? null : {
+						code: out.code,
+						map: null
+					};
+				}
+			},
+			handleHotUpdate() {
+				operations = void 0;
+			}
+		},
+		devtoolsPlugin(),
+		gluePlugin({
+			name: "forms:glue",
+			package: "@menapo/forms",
+			hooks: ["useForm"],
+			module: (framework) => GLUE + (framework === "svelte" ? "svelte.svelte" : framework) + EXT,
+			dirs: [GLUE],
+			framework: options.framework
+		})
+	];
+}
+//#endregion
+export { forms as default, forms };