@kasperrt/smolter 0.3.0 → 0.3.1

package/.generated/client/deployment.ts

@@ -0,0 +1,161 @@
+import type { NavigationRouter } from "../core/index.ts";
+
+/** Build identity and the fresh, non-cacheable manifest URL emitted by deploymentPlugin. */
+export interface DeploymentOptions {
+  version: string;
+  manifestURL: string;
+  /** Maximum time to wait for the update check before continuing navigation. */
+  timeout?: number;
+  /** Override document navigation, for example to ask about unsaved changes. */
+  reload?: (destination: URL) => void;
+}
+
+/** Check for deployment changes before navigation. Returns a cleanup function. */
+export function watchDeployment(
+  router: NavigationRouter,
+  options: DeploymentOptions | null,
+): () => void {
+  if (!options || typeof window === "undefined") return () => {};
+
+  const { version, manifestURL, timeout = 2000 } = options;
+  const navigate = router.navigate;
+  const dispose = router.dispose;
+  const manifest = new URL(manifestURL, location.href);
+  const key = `smolter:deployment:${manifest.href}:${version}`;
+  let sequence = 0;
+  let stopped = false;
+  let replay = false;
+  let destination = new URL(location.href);
+  let pending: Promise<boolean> | undefined;
+  let controller: AbortController | undefined;
+
+  function changed() {
+    if (pending) return pending;
+
+    controller = new AbortController();
+    const timer = setTimeout(() => controller?.abort(), timeout);
+    pending = fetch(manifest, { cache: "no-store", signal: controller.signal })
+      .then(async (response) => {
+        if (!response.ok) return false;
+
+        const data: unknown = await response.json();
+
+        return (
+          typeof data === "object" &&
+          data !== null &&
+          "version" in data &&
+          typeof data.version === "string" &&
+          data.version.length > 0 &&
+          data.version !== version
+        );
+      })
+      .catch(() => false)
+      .finally(() => {
+        clearTimeout(timer);
+        pending = undefined;
+      });
+
+    return pending;
+  }
+
+  async function reload(target: URL) {
+    // If storage is unavailable, do not risk reloading the same cached document forever.
+    const allowed = await Promise.resolve()
+      .then(() => {
+        if (sessionStorage.getItem(key)) return false;
+
+        sessionStorage.setItem(key, "1");
+
+        return true;
+      })
+      .catch(() => false);
+
+    if (allowed && !stopped) {
+      if (options?.reload) options.reload(target);
+      if (!options?.reload) {
+        if (target.href === location.href) location.reload();
+        if (target.href !== location.href) location.assign(target.href);
+      }
+    }
+
+    return allowed && !stopped;
+  }
+
+  const guarded: NavigationRouter["navigate"] = async (href, operation) => {
+    const target = new URL(href, router.getSnapshot().url);
+    const currentURL = new URL(router.getSnapshot().url);
+    const current = ++sequence;
+    destination = target;
+
+    if (
+      target.origin === location.origin &&
+      (target.pathname !== currentURL.pathname ||
+        target.search !== currentURL.search) &&
+      (await changed())
+    ) {
+      if (current !== sequence || stopped || (await reload(target))) return;
+    }
+
+    if (current === sequence && !stopped) await navigate(href, operation);
+  };
+
+  const pop = (event: PopStateEvent) => {
+    if (replay) return;
+
+    const target = new URL(location.href);
+    const previous = new URL(router.getSnapshot().url);
+
+    if (
+      target.pathname === previous.pathname &&
+      target.search === previous.search
+    )
+      return;
+
+    event.stopImmediatePropagation();
+    const current = ++sequence;
+    destination = target;
+    void changed().then(async (updated) => {
+      if (stopped || current !== sequence) return;
+      if (updated && (await reload(target))) return;
+
+      replay = true;
+      window.dispatchEvent(
+        new PopStateEvent("popstate", { state: event.state }),
+      );
+      replay = false;
+    });
+  };
+
+  const preloadError = () => {
+    if (router.getSnapshot().state === "submitting") return;
+
+    const current = sequence;
+    const target = destination;
+    void changed().then((updated) => {
+      if (updated && current === sequence && !stopped) return reload(target);
+    });
+  };
+
+  function cleanup() {
+    stopped = true;
+    sequence++;
+    controller?.abort();
+    window.removeEventListener("popstate", pop, true);
+    window.removeEventListener("vite:preloadError", preloadError);
+
+    if (router.navigate === guarded) router.navigate = navigate;
+    if (router.dispose === guardedDispose) router.dispose = dispose;
+  }
+
+  function guardedDispose() {
+    cleanup();
+    dispose();
+  }
+
+  router.navigate = guarded;
+  router.dispose = guardedDispose;
+  window.addEventListener("popstate", pop, true);
+  window.addEventListener("vite:preloadError", preloadError);
+
+  return cleanup;
+}

package/.generated/client/index.ts

@@ -83,3 +83,5 @@ export function serverRoute<M extends RouteModule = RouteModule>(
     }),
   } as Route<M>;
 }
+
+export { type DeploymentOptions, watchDeployment } from "./deployment.ts";

package/.generated/vite/application/lazy-files.ts

@@ -64,6 +64,8 @@ export function lazyFiles(directory: string): Plugin {
 
       if (routes instanceof Error) return this.error(routes.message);
 
+      modules.clear();
+
       const definitions: string[] = [];
 
       for (const route of routes) {

package/.generated/vite/deployment.ts

@@ -0,0 +1,46 @@
+import { randomUUID } from "node:crypto";
+import type { Plugin } from "vite";
+
+/** Deployment manifest configuration. Serve the emitted file with Cache-Control: no-store. */
+export interface DeploymentPluginOptions {
+  /** Public URL, optionally on an asset host. Defaults to Vite base + smolter-manifest.json. */
+  manifestURL?: string;
+}
+
+/** Emit a build manifest and expose its identity through virtual:smolter/deployment. */
+export function deploymentPlugin(
+  options: DeploymentPluginOptions = {},
+): Plugin {
+  const version = randomUUID();
+  const virtualId = "\0virtual:smolter/deployment";
+  let enabled = false;
+  let manifestURL = "";
+
+  return {
+    name: "smolter-deployment",
+    configResolved(config) {
+      enabled = config.command === "build" && !config.build.ssr;
+      manifestURL =
+        options.manifestURL ?? `${config.base}smolter-manifest.json`;
+    },
+    resolveId(id) {
+      if (id === "virtual:smolter/deployment") return virtualId;
+    },
+    load(id) {
+      if (id !== virtualId) return;
+
+      const deployment = enabled ? { version, manifestURL } : null;
+
+      return `export default ${JSON.stringify(deployment)};`;
+    },
+    generateBundle() {
+      if (!enabled) return;
+
+      this.emitFile({
+        type: "asset",
+        fileName: "smolter-manifest.json",
+        source: JSON.stringify({ version }),
+      });
+    },
+  };
+}

package/.generated/vite/index.ts

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { flatRoutes } from "../files/index.ts";
 import { type Plugin, transformWithOxc } from "vite";
 import { configureTransport } from "./transport.ts";
@@ -185,11 +185,18 @@ export function routerPlugin({
       server.watcher.add(root);
 
       const refresh = (file: string) => {
-        if (!file.startsWith(`${root}/`)) return;
+        if (clientRoutes || serverRoutes) return;
 
-        const module = server.moduleGraph.getModuleById(virtualId);
+        const path = relative(root, file).replaceAll("\\", "/");
 
-        if (module) server.moduleGraph.invalidateModule(module);
+        if (!/^(?:[^/]+\.[jt]sx?|[^/]+\/route\.[jt]sx?)$/.test(path)) return;
+        if (path.endsWith(".d.ts")) return;
+
+        for (const environment of Object.values(server.environments)) {
+          const module = environment.moduleGraph.getModuleById(virtualId);
+
+          if (module) environment.moduleGraph.invalidateModule(module);
+        }
 
         server.ws.send({ type: "full-reload" });
       };

package/.generated/vite/preact.ts

@@ -22,3 +22,8 @@ export {
   applicationPlugins,
   preactConfig,
 } from "./application/vite.ts";
+
+export {
+  type DeploymentPluginOptions,
+  deploymentPlugin,
+} from "./deployment.ts";

package/.generated/vite/react.ts

@@ -16,3 +16,8 @@ export function routerPlugin(options: FileRouterOptions = {}): Plugin {
 
 /** File routing is the default; this alias keeps configuration explicit. */
 export const fileRouter = routerPlugin;
+
+export {
+  type DeploymentPluginOptions,
+  deploymentPlugin,
+} from "./deployment.ts";

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.3.1
+
+- Refresh browser and SSR file-route discovery on additions, renames and removals; preserve normal Vite HMR for colocated helpers and components.
+
+- Add optional production deployment manifests through `deploymentPlugin` for both React and Preact Vite integrations.
+- Add `watchDeployment` to both client entrypoints: check before navigation and Back/Forward, recover stale Vite chunks after confirmed build changes, and preserve the requested URL.
+- Skip hash-only links, development builds and SSR; bound failed checks and prevent repeated reloads. Keep routing-only bundles unchanged.
+- Document production cache headers, CDN/application-specific manifest paths, unsaved state and rollout limitations.
+
 ## 0.3.0
 
 ### Migration from 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # smolter _
 
 <!-- bundlejs:start -->
-[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.0%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.0%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&bundle)
-[![preact gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.0%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.0%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&bundle)
+[![react gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.1%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.1%2Freact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22react%22%2C%22react%2F*%22%5D%7D%7D&bundle)
+[![preact gzip size](https://deno.bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.1%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&badge)](https://bundlejs.com/?q=%40kasperrt%2Fsmolter%400.3.1%2Fpreact&treeshake=%5B*%5D&config=%7B%22compression%22%3A%22gzip%22%2C%22esbuild%22%3A%7B%22external%22%3A%5B%22preact%22%2C%22preact%2F*%22%5D%7D%7D&bundle)
 <!-- bundlejs:end -->
 
 A typed data router for React and Preact. **Zero runtime dependencies.**
@@ -20,6 +20,8 @@ Start with [loaders](https://kasperrt.github.io/smolter/react/docs/loaders/), [a
 
 ## Contents
 
+- [Deployment updates](#deployment-updates)
+
 - [Install](#install)
 - [Try the four standalone examples](#try-the-four-standalone-examples)
 - [Choose file routing or manual routes](#choose-file-routing-or-manual-routes)
@@ -567,6 +569,22 @@ This optional entry does not contribute to the base React bundle measurement.
 
 ## Size and checks
 
+| Need | Public import |
+| --- | --- |
+| Navigation only | `@kasperrt/smolter/react` or `/preact`, using `createRouter` |
+| Loaders, actions, forms and fetchers | Same entry, using `createDataRouter` |
+| Browser server-request transport | Renderer `/client` subpath |
+| Preact application hydration | `@kasperrt/smolter/preact/client` |
+| Preact document components | `@kasperrt/smolter/preact/document` |
+| Lazy Preact route modules | `@kasperrt/smolter/preact/lazy-route` |
+| Optional React resources | `@kasperrt/smolter/react/data` |
+| Server rendering / Vite integration | Renderer `/server` / `/vite` subpaths; keep out of browser imports |
+
+The measurements below describe retained exports, not the cost of an import
+statement. Browser transport rows include the router and transport together;
+application rows include the listed modules together. Server and Vite modules
+have no browser cost when kept in their intended server/build entrypoints.
+
 Use `createRouter` for navigation only, or `createDataRouter` for loaders,
 actions, fetchers and revalidation. Both are named exports from
 `@kasperrt/smolter/preact` and `/react`. No extra package or plugin is required.
@@ -581,14 +599,16 @@ a claim of identical features.
 <!-- size-comparison:start -->
 | Browser exports | Gzip bytes |
 | --- | ---: |
+| `React Router: declarative routing subset` | 12882 |
+| `React Router: data routing subset` | 29780 |
 | `React: routing-only named exports` | 1245 |
 | `Preact: routing-only named exports` | 1405 |
 | `@kasperrt/smolter/react` | 2873 |
 | `@kasperrt/smolter/preact` | 4748 |
-| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 3219 |
-| `@kasperrt/smolter/preact + server transport` | 5059 |
-| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 7415 |
-| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 7696 |
+| `@kasperrt/smolter/react + @kasperrt/smolter/react/client` | 3870 |
+| `@kasperrt/smolter/preact + server transport` | 5697 |
+| `@kasperrt/smolter/preact + client + document (application without lazy routes)` | 8033 |
+| `@kasperrt/smolter/preact + client + document + lazy-route (file-routed application)` | 8317 |
 | `@kasperrt/smolter/react/data (optional resource API)` | 2962 |
 | `React: common routing/data exports` | 2683 |
 | `Preact: common routing/data exports` | 2966 |
@@ -604,6 +624,13 @@ The common-export rows measure the same named API set: `createDataRouter`,
 `useLoaderData`, `useActionData`, `useParams`, `useLocation`,
 `useRevalidator` and `useFetcher`. Preact’s link and submission APIs currently
 have additional behavior; equal names do not imply identical implementations.
+React Router's declarative subset retains `BrowserRouter`, `Routes`, `Route`,
+`Link`, `useParams`, and `useLocation`. Its data subset retains
+`createBrowserRouter`, `RouterProvider`, `Link`, `Form`, `useLoaderData`,
+`useActionData`, `useParams`, `useLocation`, `useRevalidator`, and `useFetcher`.
+React Router has no dedicated Preact entry; these are React API measurements,
+not a Preact compatibility build. The selected APIs have different capabilities.
+
 The routing-only rows retain `createRouter`, `defineRoute`, `RouterProvider`,
 `Routes`, `Link`, `useParams` and `useLocation`. Full Preact also exposes richer
 application APIs. These tiers overlap: do not add the rows together.
@@ -683,3 +710,26 @@ pnpm add /absolute/path/to/kasperrt-smolter-0.0.1.tgz
 ```
 
 Workspace structure and rendering checks are documented in [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## Deployment updates
+
+For production tabs that survive a deployment, add `deploymentPlugin()` from
+`@kasperrt/smolter/react/vite` or `/preact/vite`, then connect the router:
+
+```ts
+import deployment from "virtual:smolter/deployment";
+import { watchDeployment } from "@kasperrt/smolter/preact/client";
+
+watchDeployment(router, deployment);
+```
+
+Serve the emitted `smolter-manifest.json` with `Cache-Control: no-store` and HTML
+with `no-cache`. Navigation checks its build version before loading another route;
+a newer version reloads the destination, including its query and hash. Vite chunk
+failures are checked again. Hash-only links skip the check, failed checks continue
+normally, and a session marker prevents reload loops. Development/SSR builds
+disable the helper. This optional client module adds nothing to the routing-only
+entrypoints and never replays form submissions.
+
+See [deployment updates](https://kasperrt.github.io/smolter/react/docs/deployments/)
+for Express, CDN paths, TypeScript declarations and unsaved-state handling.

package/dist/client/deployment.d.ts

@@ -0,0 +1,12 @@
+import type { NavigationRouter } from "../core/index.ts";
+/** Build identity and the fresh, non-cacheable manifest URL emitted by deploymentPlugin. */
+export interface DeploymentOptions {
+    version: string;
+    manifestURL: string;
+    /** Maximum time to wait for the update check before continuing navigation. */
+    timeout?: number;
+    /** Override document navigation, for example to ask about unsaved changes. */
+    reload?: (destination: URL) => void;
+}
+/** Check for deployment changes before navigation. Returns a cleanup function. */
+export declare function watchDeployment(router: NavigationRouter, options: DeploymentOptions | null): () => void;

package/dist/client/deployment.js

@@ -0,0 +1,102 @@
+//#region .generated/client/deployment.ts
+/** Check for deployment changes before navigation. Returns a cleanup function. */
+function watchDeployment(router, options) {
+	if (!options || typeof window === "undefined") return () => {};
+	const { version, manifestURL, timeout = 2e3 } = options;
+	const navigate = router.navigate;
+	const dispose = router.dispose;
+	const manifest = new URL(manifestURL, location.href);
+	const key = `smolter:deployment:${manifest.href}:${version}`;
+	let sequence = 0;
+	let stopped = false;
+	let replay = false;
+	let destination = new URL(location.href);
+	let pending;
+	let controller;
+	function changed() {
+		if (pending) return pending;
+		controller = new AbortController();
+		const timer = setTimeout(() => controller?.abort(), timeout);
+		pending = fetch(manifest, {
+			cache: "no-store",
+			signal: controller.signal
+		}).then(async (response) => {
+			if (!response.ok) return false;
+			const data = await response.json();
+			return typeof data === "object" && data !== null && "version" in data && typeof data.version === "string" && data.version.length > 0 && data.version !== version;
+		}).catch(() => false).finally(() => {
+			clearTimeout(timer);
+			pending = void 0;
+		});
+		return pending;
+	}
+	async function reload(target) {
+		const allowed = await Promise.resolve().then(() => {
+			if (sessionStorage.getItem(key)) return false;
+			sessionStorage.setItem(key, "1");
+			return true;
+		}).catch(() => false);
+		if (allowed && !stopped) {
+			if (options?.reload) options.reload(target);
+			if (!options?.reload) {
+				if (target.href === location.href) location.reload();
+				if (target.href !== location.href) location.assign(target.href);
+			}
+		}
+		return allowed && !stopped;
+	}
+	const guarded = async (href, operation) => {
+		const target = new URL(href, router.getSnapshot().url);
+		const currentURL = new URL(router.getSnapshot().url);
+		const current = ++sequence;
+		destination = target;
+		if (target.origin === location.origin && (target.pathname !== currentURL.pathname || target.search !== currentURL.search) && await changed()) {
+			if (current !== sequence || stopped || await reload(target)) return;
+		}
+		if (current === sequence && !stopped) await navigate(href, operation);
+	};
+	const pop = (event) => {
+		if (replay) return;
+		const target = new URL(location.href);
+		const previous = new URL(router.getSnapshot().url);
+		if (target.pathname === previous.pathname && target.search === previous.search) return;
+		event.stopImmediatePropagation();
+		const current = ++sequence;
+		destination = target;
+		changed().then(async (updated) => {
+			if (stopped || current !== sequence) return;
+			if (updated && await reload(target)) return;
+			replay = true;
+			window.dispatchEvent(new PopStateEvent("popstate", { state: event.state }));
+			replay = false;
+		});
+	};
+	const preloadError = () => {
+		if (router.getSnapshot().state === "submitting") return;
+		const current = sequence;
+		const target = destination;
+		changed().then((updated) => {
+			if (updated && current === sequence && !stopped) return reload(target);
+		});
+	};
+	function cleanup() {
+		stopped = true;
+		sequence++;
+		controller?.abort();
+		window.removeEventListener("popstate", pop, true);
+		window.removeEventListener("vite:preloadError", preloadError);
+		if (router.navigate === guarded) router.navigate = navigate;
+		if (router.dispose === guardedDispose) router.dispose = dispose;
+	}
+	function guardedDispose() {
+		cleanup();
+		dispose();
+	}
+	router.navigate = guarded;
+	router.dispose = guardedDispose;
+	window.addEventListener("popstate", pop, true);
+	window.addEventListener("vite:preloadError", preloadError);
+	return cleanup;
+}
+//#endregion
+export { watchDeployment };

package/dist/client/index.d.ts

@@ -22,3 +22,4 @@ export interface ServerHandlers {
 }
 /** Browser transport for server routes. File-router builds generate this call. */
 export declare function serverRoute<M extends RouteModule = RouteModule>(path: string, module: ClientRouteModule, handlers?: ServerHandlers): Route<M>;
+export { type DeploymentOptions, watchDeployment } from "./deployment.ts";

package/dist/client/index.js

@@ -1,4 +1,5 @@
 import { deserialize } from "./deserialize.js";
+import { watchDeployment } from "./deployment.js";
 //#region .generated/client/index.ts
 /** Browser transport for server routes. File-router builds generate this call. */
 function serverRoute(path, module, handlers = {
@@ -43,4 +44,4 @@ function serverRoute(path, module, handlers = {
 	};
 }
 //#endregion
-export { deserialize, serverRoute };
+export { deserialize, serverRoute, watchDeployment };

package/dist/preact/client.js

@@ -6,6 +6,7 @@ import { connectNavigation } from "../core/navigation.js";
 import { attachRootData } from "./root-data.js";
 import { RouterApplication, prepareRoutes } from "./router.js";
 import { deserialize } from "../client/deserialize.js";
+import { watchDeployment } from "../client/deployment.js";
 import { serverRoute } from "../client/index.js";
 import { flushSync } from "preact/compat";
 import { jsx } from "preact/jsx-runtime";
@@ -64,4 +65,4 @@ function connectHashHistory(router) {
 	};
 }
 //#endregion
-export { configureApplication, deserialize, mountApplication, serverRoute };
+export { configureApplication, deserialize, mountApplication, serverRoute, watchDeployment };

package/dist/vite/application/lazy-files.js

@@ -45,6 +45,7 @@ function lazyFiles(directory) {
 			if (id !== "\0virtual:smolter/routes" || options?.ssr) return;
 			const routes = await flatRoutes(root);
 			if (routes instanceof Error) return this.error(routes.message);
+			modules.clear();
 			const definitions = [];
 			for (const route of routes) {
 				this.addWatchFile(route.file);

package/dist/vite/deployment.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "vite";
+/** Deployment manifest configuration. Serve the emitted file with Cache-Control: no-store. */
+export interface DeploymentPluginOptions {
+    /** Public URL, optionally on an asset host. Defaults to Vite base + smolter-manifest.json. */
+    manifestURL?: string;
+}
+/** Emit a build manifest and expose its identity through virtual:smolter/deployment. */
+export declare function deploymentPlugin(options?: DeploymentPluginOptions): Plugin;

package/dist/vite/deployment.js

@@ -0,0 +1,36 @@
+import { randomUUID } from "node:crypto";
+//#region .generated/vite/deployment.ts
+/** Emit a build manifest and expose its identity through virtual:smolter/deployment. */
+function deploymentPlugin(options = {}) {
+	const version = randomUUID();
+	const virtualId = "\0virtual:smolter/deployment";
+	let enabled = false;
+	let manifestURL = "";
+	return {
+		name: "smolter-deployment",
+		configResolved(config) {
+			enabled = config.command === "build" && !config.build.ssr;
+			manifestURL = options.manifestURL ?? `${config.base}smolter-manifest.json`;
+		},
+		resolveId(id) {
+			if (id === "virtual:smolter/deployment") return virtualId;
+		},
+		load(id) {
+			if (id !== virtualId) return;
+			return `export default ${JSON.stringify(enabled ? {
+				version,
+				manifestURL
+			} : null)};`;
+		},
+		generateBundle() {
+			if (!enabled) return;
+			this.emitFile({
+				type: "asset",
+				fileName: "smolter-manifest.json",
+				source: JSON.stringify({ version })
+			});
+		}
+	};
+}
+//#endregion
+export { deploymentPlugin };

package/dist/vite/index.js

@@ -1,7 +1,7 @@
 import { flatRoutes } from "../files/index.js";
 import { configureTransport } from "./transport.js";
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { transformWithOxc } from "vite";
 //#region .generated/vite/index.ts
 /** Build-time flat route discovery and the optional server data transport. */
@@ -83,9 +83,14 @@ function routerPlugin({ directory = "src/routes", clientRoutes, serverRoutes, fr
 		configureServer(server) {
 			server.watcher.add(root);
 			const refresh = (file) => {
-				if (!file.startsWith(`${root}/`)) return;
-				const module = server.moduleGraph.getModuleById(virtualId);
-				if (module) server.moduleGraph.invalidateModule(module);
+				if (clientRoutes || serverRoutes) return;
+				const path = relative(root, file).replaceAll("\\", "/");
+				if (!/^(?:[^/]+\.[jt]sx?|[^/]+\/route\.[jt]sx?)$/.test(path)) return;
+				if (path.endsWith(".d.ts")) return;
+				for (const environment of Object.values(server.environments)) {
+					const module = environment.moduleGraph.getModuleById(virtualId);
+					if (module) environment.moduleGraph.invalidateModule(module);
+				}
 				server.ws.send({ type: "full-reload" });
 			};
 			server.watcher.on("add", refresh);

package/dist/vite/preact.d.ts

@@ -9,3 +9,4 @@ export declare function routerPlugin(options?: FileRouterOptions): Plugin;
 export declare const fileRouter: typeof routerPlugin;
 export type { ApplicationOptions } from "./application/vite.ts";
 export { applicationPlugins, preactConfig, } from "./application/vite.ts";
+export { type DeploymentPluginOptions, deploymentPlugin, } from "./deployment.ts";

package/dist/vite/preact.js

@@ -1,5 +1,6 @@
 import { flatRoutes } from "../files/index.js";
 import { routerPlugin as routerPlugin$1 } from "./index.js";
+import { deploymentPlugin } from "./deployment.js";
 import { applicationPlugins, preactConfig } from "./application/vite.js";
 //#region .generated/vite/preact.ts
 /** Configure flat routes and server transport for Preact. */
@@ -12,4 +13,4 @@ function routerPlugin(options = {}) {
 /** File routing is the default; this alias keeps configuration explicit. */
 var fileRouter = routerPlugin;
 //#endregion
-export { applicationPlugins, fileRouter, flatRoutes, preactConfig, routerPlugin };
+export { applicationPlugins, deploymentPlugin, fileRouter, flatRoutes, preactConfig, routerPlugin };

package/dist/vite/react.d.ts

@@ -7,3 +7,4 @@ export type { FileRouterOptions } from "./index.ts";
 export declare function routerPlugin(options?: FileRouterOptions): Plugin;
 /** File routing is the default; this alias keeps configuration explicit. */
 export declare const fileRouter: typeof routerPlugin;
+export { type DeploymentPluginOptions, deploymentPlugin, } from "./deployment.ts";

package/dist/vite/react.js

@@ -1,5 +1,6 @@
 import { flatRoutes } from "../files/index.js";
 import { routerPlugin as routerPlugin$1 } from "./index.js";
+import { deploymentPlugin } from "./deployment.js";
 //#region .generated/vite/react.ts
 /** Configure flat routes and server transport for React. */
 function routerPlugin(options = {}) {
@@ -11,4 +12,4 @@ function routerPlugin(options = {}) {
 /** File routing is the default; this alias keeps configuration explicit. */
 var fileRouter = routerPlugin;
 //#endregion
-export { fileRouter, flatRoutes, routerPlugin };
+export { deploymentPlugin, fileRouter, flatRoutes, routerPlugin };

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@kasperrt/smolter",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "exports": {
     "./react": "./.generated/react/index.ts",
     "./preact": "./.generated/preact/index.ts",

package/package.json

@@ -56,7 +56,7 @@
     "wouter": "3.13.0",
     "wouter-preact": "3.13.0"
   },
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A tiny typed data router for React and Preact.",
   "sideEffects": false,
   "license": "MIT",
@@ -154,7 +154,7 @@
       "optional": true
     }
   },
-  "author": "Kasper Rynning-T\u00f8nnesen <kasperrt@users.noreply.github.com> (https://github.com/kasperrt)",
+  "author": "Kasper Rynning-Tønnesen <kasperrt@users.noreply.github.com> (https://github.com/kasperrt)",
   "homepage": "https://kasperrt.github.io/smolter/",
   "bugs": {
     "url": "https://github.com/kasperrt/smolter/issues"