camox 0.0.0 → 0.1.2-alpha.2

package/dist/features/studio/studioStore.js

@@ -0,0 +1,44 @@
+import { createStore } from "@xstate/store";
+//#region src/features/studio/studioStore.ts
+var studioStore = createStore({
+	context: {
+		isCommandPaletteOpen: false,
+		commandPalettePages: []
+	},
+	on: {
+		openCommandPalette: (context) => {
+			return {
+				...context,
+				isCommandPaletteOpen: true
+			};
+		},
+		closeCommandPalette: (context) => {
+			return {
+				...context,
+				isCommandPaletteOpen: false,
+				commandPalettePage: null
+			};
+		},
+		toggleCommandPalette: (context) => {
+			return {
+				...context,
+				isCommandPaletteOpen: !context.isCommandPaletteOpen,
+				commandPalettePages: []
+			};
+		},
+		pushCommandPalettePage: (context, event) => {
+			return {
+				...context,
+				commandPalettePages: [...context.commandPalettePages, event.page]
+			};
+		},
+		popCommandPalettePage: (context) => {
+			return {
+				...context,
+				commandPalettePages: context.commandPalettePages.slice(0, -1)
+			};
+		}
+	}
+});
+//#endregion
+export { studioStore };

package/dist/features/studio/useTheme.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+type Theme = "dark" | "light" | "system";
+export declare function useTheme(): {
+    theme: Theme;
+    setTheme: React.Dispatch<React.SetStateAction<Theme>>;
+};
+export declare function useThemeActions(): void;
+export {};
+//# sourceMappingURL=useTheme.d.ts.map

package/dist/features/studio/useTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTheme.d.ts","sourceRoot":"","sources":["../../../src/features/studio/useTheme.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B,KAAK,KAAK,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAazC,wBAAgB,QAAQ;;;EAiDvB;AAED,wBAAgB,eAAe,SAqD9B"}

package/dist/features/studio/useTheme.js

@@ -0,0 +1,98 @@
+import { actionsStore } from "../provider/actionsStore.js";
+import * as React from "react";
+//#region src/features/studio/useTheme.ts
+var getThemeIcon = (theme) => {
+	switch (theme) {
+		case "dark": return "Moon";
+		case "light": return "Sun";
+		case "system": return "Monitor";
+	}
+};
+function useTheme() {
+	const [theme, setTheme] = React.useState(() => {
+		if (typeof window !== "undefined") return localStorage.getItem("theme") || "system";
+		return "system";
+	});
+	const applyTheme = (themeToApply) => {
+		const root = window.document.documentElement;
+		root.classList.remove("light", "dark");
+		root.classList.add(themeToApply);
+	};
+	React.useEffect(() => {
+		const root = window.document.documentElement;
+		root.classList.remove("light", "dark");
+		if (theme === "system") {
+			const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+			const updateSystemTheme = () => {
+				applyTheme(mediaQuery.matches ? "dark" : "light");
+			};
+			updateSystemTheme();
+			mediaQuery.addEventListener("change", updateSystemTheme);
+			return () => mediaQuery.removeEventListener("change", updateSystemTheme);
+		}
+		root.classList.add(theme);
+	}, [theme]);
+	React.useEffect(() => {
+		localStorage.setItem("theme", theme);
+	}, [theme]);
+	return {
+		theme,
+		setTheme
+	};
+}
+function useThemeActions() {
+	const { theme, setTheme } = useTheme();
+	React.useEffect(() => {
+		const pageId = "change-theme";
+		const actions = [
+			{
+				id: pageId,
+				label: "Change theme",
+				groupLabel: "Studio",
+				checkIfAvailable: () => true,
+				hasChildren: true,
+				execute: () => {},
+				icon: getThemeIcon(theme)
+			},
+			{
+				id: "switch-to-light-theme",
+				parentActionId: pageId,
+				label: "Switch to light theme",
+				groupLabel: "Studio",
+				checkIfAvailable: () => theme !== "light",
+				execute: () => setTheme("light"),
+				icon: "Sun"
+			},
+			{
+				id: "switch-to-dark-theme",
+				parentActionId: pageId,
+				label: "Switch to dark theme",
+				groupLabel: "Studio",
+				checkIfAvailable: () => theme !== "dark",
+				execute: () => setTheme("dark"),
+				icon: "Moon"
+			},
+			{
+				id: "switch-to-system-theme",
+				parentActionId: pageId,
+				label: "Switch to system theme",
+				groupLabel: "Studio",
+				checkIfAvailable: () => theme !== "system",
+				execute: () => setTheme("system"),
+				icon: "Monitor"
+			}
+		];
+		actionsStore.send({
+			type: "registerManyActions",
+			actions
+		});
+		return () => {
+			actionsStore.send({
+				type: "unregisterManyActions",
+				ids: actions.map((a) => a.id)
+			});
+		};
+	}, [theme, setTheme]);
+}
+//#endregion
+export { useTheme, useThemeActions };

package/dist/features/vite/appGeneration.d.ts

@@ -0,0 +1,4 @@
+import { ViteDevServer } from 'vite';
+export declare function generateAppFile(appRoot: string): void;
+export declare function watchAppFile(server: ViteDevServer, appRoot: string): void;
+//# sourceMappingURL=appGeneration.d.ts.map

package/dist/features/vite/appGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appGeneration.d.ts","sourceRoot":"","sources":["../../../src/features/vite/appGeneration.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AA6C1C,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,QAI9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,QA6BlE"}

package/dist/features/vite/appGeneration.js

@@ -0,0 +1,67 @@
+import { writeIfChanged } from "./utils.js";
+import { readFileSync, writeFileSync } from "node:fs";
+import { relative, resolve } from "node:path";
+//#region src/features/vite/appGeneration.ts
+var HEADER = `/* ============================================================================
+ * AUTO-GENERATED BY CAMOX — DO NOT EDIT
+ *
+ * This file is managed by the Camox Vite plugin and should stay gitignored.
+ * Any manual edits will be automatically reverted by the dev server.
+ * ============================================================================ */
+
+`;
+function generateCamoxApp() {
+	return HEADER + `import { createApp } from 'camox/createApp';
+import type { Block } from 'camox/createBlock';
+import type { Layout } from 'camox/createLayout';
+
+// Auto-import all blocks from the blocks directory
+const blockModules = import.meta.glob<{ block: Block }>('./blocks/*.{ts,tsx}', {
+  eager: true,
+});
+const blocks = Object.values(blockModules).map((mod) => mod.block);
+
+// Auto-import all layouts from the layouts directory
+const layoutModules = import.meta.glob<{ layout: Layout }>(
+  './layouts/*.{ts,tsx}',
+  { eager: true },
+);
+const layouts = Object.values(layoutModules).map((mod) => mod.layout);
+
+export const camoxApp = createApp({
+  blocks,
+  layouts,
+});
+`;
+}
+function getAppFileEntries(appRoot) {
+	return [{
+		path: resolve(appRoot, "src/camox/app.ts"),
+		content: generateCamoxApp()
+	}];
+}
+function generateAppFile(appRoot) {
+	for (const entry of getAppFileEntries(appRoot)) writeIfChanged(entry.path, entry.content);
+}
+function watchAppFile(server, appRoot) {
+	const entries = getAppFileEntries(appRoot);
+	const expectedByPath = new Map(entries.map((e) => [e.path, e.content]));
+	server.watcher.on("change", (changedPath) => {
+		const expected = expectedByPath.get(changedPath);
+		if (!expected) return;
+		if (readFileSync(changedPath, "utf-8") !== expected) {
+			const rel = relative(server.config.root, changedPath);
+			server.config.logger.warn(`Camox app file "${rel}" was modified — reverting to generated version.`, { timestamp: true });
+			writeFileSync(changedPath, expected, "utf-8");
+		}
+	});
+	server.watcher.on("unlink", (deletedPath) => {
+		const expected = expectedByPath.get(deletedPath);
+		if (!expected) return;
+		const rel = relative(server.config.root, deletedPath);
+		server.config.logger.warn(`Camox app file "${rel}" was deleted — recreating.`, { timestamp: true });
+		writeFileSync(deletedPath, expected, "utf-8");
+	});
+}
+//#endregion
+export { generateAppFile, watchAppFile };

package/dist/features/vite/blockBoilerplate.d.ts

@@ -0,0 +1,3 @@
+import { ViteDevServer } from 'vite';
+export declare function watchNewBlockFiles(server: ViteDevServer): void;
+//# sourceMappingURL=blockBoilerplate.d.ts.map

package/dist/features/vite/blockBoilerplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockBoilerplate.d.ts","sourceRoot":"","sources":["../../../src/features/vite/blockBoilerplate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAoD1C,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,QA4BvD"}

package/dist/features/vite/blockBoilerplate.js

@@ -0,0 +1,59 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+//#region src/features/vite/blockBoilerplate.ts
+var MAX_EMPTY_BLOCK_CHARACTER_COUNT = 50;
+function kebabToCamel(str) {
+	return str.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function kebabToPascal(str) {
+	const camel = kebabToCamel(str);
+	return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function kebabToTitle(str) {
+	return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function getBlockBoilerplate(filename) {
+	const name = filename.replace(/\.tsx?$/, "");
+	const camelName = kebabToCamel(name);
+	const pascalName = kebabToPascal(name);
+	return `import { Type, createBlock } from "camox/createBlock";
+
+const ${camelName} = createBlock({
+  id: "${name}",
+  title: "${kebabToTitle(name)}",
+  description: "Describe when the AI should use this block.",
+  content: {
+    title: Type.String({ default: "Title" }),
+  },
+  component: ${pascalName}Component,
+});
+
+function ${pascalName}Component() {
+  return (
+    <section>
+      <${camelName}.Field name="title">
+        {(content) => <h1>{content}</h1>}
+      </${camelName}.Field>
+    </section>
+  );
+}
+
+export { ${camelName} as block };
+`;
+}
+function watchNewBlockFiles(server) {
+	const blocksDir = resolve(server.config.root, "src/camox/blocks");
+	server.watcher.on("add", (filePath) => {
+		if (filePath.startsWith(blocksDir) && /\.tsx?$/.test(filePath) && !filePath.includes("index.")) try {
+			if (readFileSync(filePath, "utf-8").trim().length < MAX_EMPTY_BLOCK_CHARACTER_COUNT) {
+				const filename = basename(filePath);
+				writeFileSync(filePath, getBlockBoilerplate(filename));
+				server.config.logger.info(`[camox] Auto-filled block boilerplate: ${filename}`, { timestamp: true });
+			}
+		} catch {
+			server.config.logger.error(`[camox] Could not auto-fill boilerplate at path ${filePath}`, { timestamp: true });
+		}
+	});
+}
+//#endregion
+export { watchNewBlockFiles };

package/dist/features/vite/convexSync.d.ts

@@ -0,0 +1,6 @@
+import { ViteDevServer } from 'vite';
+export declare const LOCAL_CONVEX_URL = "http://127.0.0.1:3210";
+export declare const LOCAL_CONVEX_SITE_URL = "http://127.0.0.1:3211";
+export declare function startConvexDev(server: ViteDevServer): Promise<void>;
+export declare function stopConvexDev(): void;
+//# sourceMappingURL=convexSync.d.ts.map

package/dist/features/vite/convexSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convexSync.d.ts","sourceRoot":"","sources":["../../../src/features/vite/convexSync.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAE1C,eAAO,MAAM,gBAAgB,0BAA0B,CAAC;AACxD,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAwB7D,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA4EnE;AAED,wBAAgB,aAAa,IAAI,IAAI,CAKpC"}

package/dist/features/vite/convexSync.js

@@ -0,0 +1,98 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+//#region src/features/vite/convexSync.ts
+var LOCAL_CONVEX_URL = "http://127.0.0.1:3210";
+var LOCAL_CONVEX_SITE_URL = "http://127.0.0.1:3211";
+var convexProcess = null;
+function getBackendDir() {
+	return dirname(createRequire(import.meta.url).resolve("@camox/backend-content/package.json"));
+}
+/** Parse team and project slugs from .env.local CONVEX_DEPLOYMENT comment */
+function parseDeploymentInfo(backendDir) {
+	try {
+		const match = readFileSync(join(backendDir, ".env.local"), "utf-8").match(/CONVEX_DEPLOYMENT=.*#\s*team:\s*(\S+),\s*project:\s*(\S+)/);
+		if (match) return {
+			team: match[1],
+			project: match[2]
+		};
+	} catch {}
+	return null;
+}
+function startConvexDev(server) {
+	const cwd = getBackendDir();
+	const log = (msg) => server.config.logger.info(`[convex] ${msg}`, { timestamp: true });
+	const deploymentInfo = parseDeploymentInfo(cwd);
+	if (!deploymentInfo) {
+		log("Could not parse team/project from .env.local — skipping local Convex backend");
+		return Promise.resolve();
+	}
+	const args = [
+		"convex",
+		"dev",
+		"--configure",
+		"existing",
+		"--team",
+		deploymentInfo.team,
+		"--project",
+		deploymentInfo.project,
+		"--dev-deployment",
+		"local",
+		"--local-force-upgrade"
+	];
+	log(`Starting: npx ${args.join(" ")}`);
+	log(`Working directory: ${cwd}`);
+	return new Promise((resolve) => {
+		convexProcess = spawn("npx", args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			shell: true
+		});
+		log(`Spawned process with PID: ${convexProcess.pid}`);
+		let resolved = false;
+		const handleOutput = (stream) => (data) => {
+			const lines = data.toString().trim().split("\n");
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				log(`[${stream}] ${line}`);
+				if (!resolved && /convex functions ready|watching for changes/i.test(line)) {
+					log("Backend ready");
+					resolved = true;
+					resolve();
+				}
+			}
+		};
+		convexProcess.stdout?.on("data", handleOutput("stdout"));
+		convexProcess.stderr?.on("data", handleOutput("stderr"));
+		convexProcess.on("error", (err) => {
+			log(`Process error: ${err.message}`);
+			if (!resolved) {
+				resolved = true;
+				resolve();
+			}
+		});
+		convexProcess.on("close", (code, signal) => {
+			log(`Process exited with code=${code} signal=${signal}`);
+			if (!resolved) {
+				resolved = true;
+				resolve();
+			}
+		});
+		server.httpServer?.on("close", () => {
+			stopConvexDev();
+		});
+	});
+}
+function stopConvexDev() {
+	if (convexProcess) {
+		convexProcess.kill();
+		convexProcess = null;
+	}
+}
+//#endregion
+export { LOCAL_CONVEX_SITE_URL, LOCAL_CONVEX_URL, startConvexDev, stopConvexDev };

package/dist/features/vite/definitionsSync.d.ts

@@ -0,0 +1,11 @@
+import { ViteDevServer } from 'vite';
+export interface DefinitionsSyncOptions {
+    /** Stable project slug used to resolve the project */
+    projectSlug?: string;
+    /** Path to the module that exports the camoxApp (relative to project root) */
+    camoxAppPath?: string;
+    /** Convex URL to connect to for syncing definitions */
+    convexUrl?: string;
+}
+export declare function syncDefinitions(server: ViteDevServer, options?: DefinitionsSyncOptions): Promise<void>;
+//# sourceMappingURL=definitionsSync.d.ts.map

package/dist/features/vite/definitionsSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitionsSync.d.ts","sourceRoot":"","sources":["../../../src/features/vite/definitionsSync.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAO1C,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAOD,wBAAsB,eAAe,CACnC,MAAM,EAAE,aAAa,EACrB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAmOf"}

package/dist/features/vite/definitionsSync.js

@@ -0,0 +1,157 @@
+import { api } from "camox/server/api";
+import path from "node:path";
+import { ConvexClient } from "convex/browser";
+//#region src/features/vite/definitionsSync.ts
+var SYNC_DEBOUNCE_DELAY_MS = 100;
+function getBlockIdFromFilePath(filePath) {
+	return path.basename(filePath, path.extname(filePath));
+}
+async function syncDefinitions(server, options = {}) {
+	const camoxAppPath = options.camoxAppPath ?? "./src/camox/app.ts";
+	const blocksDir = path.resolve(server.config.root, "src/camox/blocks");
+	if (!options.projectSlug) {
+		server.config.logger.warn("[camox] No projectSlug provided, skipping block definitions sync", { timestamp: true });
+		return;
+	}
+	const projectSlug = options.projectSlug;
+	const convexUrl = options.convexUrl ?? process.env.VITE_CONVEX_URL;
+	if (!convexUrl) {
+		server.config.logger.warn("[camox] No Convex URL provided, skipping block definitions sync", { timestamp: true });
+		return;
+	}
+	const client = new ConvexClient(convexUrl);
+	async function getProjectId() {
+		const project = await client.query(api.projects.getProjectBySlug, { slug: projectSlug });
+		if (!project) {
+			server.config.logger.warn(`[camox] No project found with slug "${projectSlug}", skipping block definitions sync`, { timestamp: true });
+			return null;
+		}
+		return project._id;
+	}
+	async function performInitialSync() {
+		const camoxModule = await server.ssrLoadModule(camoxAppPath);
+		if (!camoxModule.camoxApp) {
+			server.config.logger.warn(`[camox] No camoxApp export found in ${camoxAppPath}`, { timestamp: true });
+			return;
+		}
+		const projectId = await getProjectId();
+		if (!projectId) return;
+		const definitions = camoxModule.camoxApp.getBlocks().map((block) => ({
+			blockId: block.id,
+			title: block.title,
+			description: block.description,
+			contentSchema: block.contentSchema,
+			settingsSchema: block.settingsSchema,
+			layoutOnly: block.layoutOnly || void 0
+		}));
+		await client.mutation(api.blockDefinitions.syncBlockDefinitions, {
+			projectId,
+			definitions
+		});
+		server.config.logger.info(`[camox] Synced ${definitions.length} block definition${definitions.length === 1 ? "" : "s"}`, { timestamp: true });
+		const layoutDefinitions = camoxModule.camoxApp.getSerializableLayoutDefinitions();
+		if (layoutDefinitions.length > 0) {
+			await client.mutation(api.layouts.syncLayouts, {
+				projectId,
+				layouts: layoutDefinitions
+			});
+			server.config.logger.info(`[camox] Synced ${layoutDefinitions.length} layout${layoutDefinitions.length === 1 ? "" : "s"}`, { timestamp: true });
+		}
+	}
+	async function upsertBlock(filePath) {
+		const relativePath = "./" + path.relative(server.config.root, filePath);
+		const moduleNode = server.moduleGraph.getModuleById(relativePath);
+		if (moduleNode) server.moduleGraph.invalidateModule(moduleNode);
+		const blockModule = await server.ssrLoadModule(relativePath);
+		if (!blockModule.block) {
+			server.config.logger.warn(`[camox] No block export found in ${relativePath}`, { timestamp: true });
+			return;
+		}
+		const block = blockModule.block;
+		const projectId = await getProjectId();
+		if (!projectId) return;
+		const result = await client.mutation(api.blockDefinitions.upsertBlockDefinition, {
+			projectId,
+			blockId: block.id,
+			title: block.title,
+			description: block.description,
+			contentSchema: block.contentSchema,
+			settingsSchema: block.settingsSchema,
+			layoutOnly: block.layoutOnly || void 0
+		});
+		server.config.logger.info(`[camox] ${result.action === "created" ? "Created" : "Updated"} block "${block.id}"`, { timestamp: true });
+	}
+	async function deleteBlock(filePath) {
+		const blockId = getBlockIdFromFilePath(filePath);
+		const projectId = await getProjectId();
+		if (!projectId) return;
+		if ((await client.mutation(api.blockDefinitions.deleteBlockDefinition, {
+			projectId,
+			blockId
+		})).deleted) server.config.logger.info(`[camox] Deleted block "${blockId}"`, { timestamp: true });
+	}
+	try {
+		await performInitialSync();
+	} catch (error) {
+		server.config.logger.error(`[camox] Failed to sync block definitions: ${error}`, { timestamp: true });
+	}
+	const debounceTimers = /* @__PURE__ */ new Map();
+	const layoutsDir = path.resolve(server.config.root, "src/camox/layouts");
+	function isBlockFile(filePath) {
+		return filePath.startsWith(blocksDir) && /\.tsx?$/.test(filePath);
+	}
+	function isLayoutFile(filePath) {
+		return filePath.startsWith(layoutsDir) && /\.tsx?$/.test(filePath);
+	}
+	const handleBlockFileUpsert = (filePath) => {
+		if (!isBlockFile(filePath)) return;
+		const existingTimer = debounceTimers.get(filePath);
+		if (existingTimer) clearTimeout(existingTimer);
+		debounceTimers.set(filePath, setTimeout(async () => {
+			debounceTimers.delete(filePath);
+			try {
+				await upsertBlock(filePath);
+			} catch (error) {
+				server.config.logger.error(`[camox] Failed to sync block: ${error}`, { timestamp: true });
+			}
+		}, SYNC_DEBOUNCE_DELAY_MS));
+	};
+	const handleBlockFileDelete = (filePath) => {
+		if (!isBlockFile(filePath)) return;
+		const existingTimer = debounceTimers.get(filePath);
+		if (existingTimer) {
+			clearTimeout(existingTimer);
+			debounceTimers.delete(filePath);
+		}
+		setTimeout(async () => {
+			try {
+				await deleteBlock(filePath);
+			} catch (error) {
+				server.config.logger.error(`[camox] Failed to delete block: ${error}`, { timestamp: true });
+			}
+		}, SYNC_DEBOUNCE_DELAY_MS);
+	};
+	let layoutSyncTimer = null;
+	const handleLayoutFileChange = (filePath) => {
+		if (!isLayoutFile(filePath)) return;
+		if (layoutSyncTimer) clearTimeout(layoutSyncTimer);
+		layoutSyncTimer = setTimeout(async () => {
+			layoutSyncTimer = null;
+			try {
+				await performInitialSync();
+			} catch (error) {
+				server.config.logger.error(`[camox] Failed to sync layouts: ${error}`, { timestamp: true });
+			}
+		}, SYNC_DEBOUNCE_DELAY_MS);
+	};
+	server.watcher.on("change", handleBlockFileUpsert);
+	server.watcher.on("change", handleLayoutFileChange);
+	server.watcher.on("add", handleBlockFileUpsert);
+	server.watcher.on("add", handleLayoutFileChange);
+	server.watcher.on("unlink", handleBlockFileDelete);
+	server.httpServer?.on("close", () => {
+		client.close();
+	});
+}
+//#endregion
+export { syncDefinitions };

package/dist/features/vite/routeGeneration.d.ts

@@ -0,0 +1,4 @@
+import { ViteDevServer } from 'vite';
+export declare function generateRouteFiles(routesDir: string, convexUrl: string, managementUrl: string): void;
+export declare function watchRouteFiles(server: ViteDevServer, routesDir: string, convexUrl: string, managementUrl: string): void;
+//# sourceMappingURL=routeGeneration.d.ts.map

package/dist/features/vite/routeGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeGeneration.d.ts","sourceRoot":"","sources":["../../../src/features/vite/routeGeneration.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAoL1C,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,QAO7F;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,EACrB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,QA8BtB"}