@solidjs/start 2.0.0-alpha.3 → 2.0.0-beta.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @solidjs/start
 
+## 2.0.0-beta.0
+
+### Minor Changes
+
+- 0a9fdc3: fix cloudflare
+
+### Patch Changes
+
+- 0c95804: Fix URL to path conversion in manifest resolver
+- 6011e5a: Fixed changes in route files resulting in a reload instead of hot module replace. Reloads now only are triggered when adding or removing routes.
+- 8fb81e6: Fixed niche edge cases in the server functions dead code removal (DCE) logic:
+  - Server functions only referenced in event handlers (e.g. `onClick`) now aren't considered unused and work properly.
+  - Unused variables in server functions no longer lead to compilation errors.
+- 8d12d6a: Fixed tailwind class changes not getting applied via HMR in filesystem routes.
+- ec1b82b: Included Vite 8 in the peer dependency range.
+
 ## 2.0.0-alpha.3
 
 ### Minor Changes

package/dist/config/constants.d.ts

@@ -11,6 +11,6 @@ export declare const VIRTUAL_MODULES: {
     readonly app: "solid-start:app";
 };
 export declare const VITE_ENVIRONMENTS: {
-    client: string;
-    server: string;
+    client: "client";
+    server: "ssr";
 };

package/dist/config/fs-routes/fs-watcher.js

@@ -1,3 +1,4 @@
+import { debounce } from "../../utils/debounce.js";
 import { VITE_ENVIRONMENTS } from "../constants.js";
 import { moduleId } from "./index.js";
 function setupWatcher(watcher, routes) {
@@ -6,37 +7,46 @@ function setupWatcher(watcher, routes) {
     watcher.on("change", path => routes.updateRoute(path));
 }
 function createRoutesReloader(server, routes, environment) {
-    routes.addEventListener("reload", handleRoutesReload);
-    return () => routes.removeEventListener("reload", handleRoutesReload);
-    function handleRoutesReload() {
-        const envName = environment === "ssr" ? VITE_ENVIRONMENTS.server : VITE_ENVIRONMENTS.client;
-        const devEnv = server.environments[envName];
-        if (!devEnv?.moduleGraph)
-            return;
+    const devEnv = server.environments[environment];
+    if (!devEnv?.moduleGraph)
+        return;
+    /**
+     * Debounce catches multiple route changes in a row
+     * Short timeout for inexpensive invalidations
+     */
+    const invalidateModule = debounce((mod) => {
+        devEnv.moduleGraph.invalidateModule(mod);
+    }, 0);
+    /**
+     * Long debounce timeout for expensive reloads
+     */
+    const reloadModule = debounce((mod) => {
+        devEnv.reloadModule(mod);
+    }, 200);
+    return routes.on("reload", function handleRoutesReload(evt) {
         const mod = devEnv.moduleGraph.getModuleById(moduleId);
-        if (mod) {
-            const seen = new Set();
-            devEnv.moduleGraph.invalidateModule(mod, seen);
+        if (!mod) {
+            devEnv.hot.send({ type: "full-reload" });
+            return;
         }
-        if (environment !== "ssr") {
-            if (mod) {
-                devEnv.reloadModule(mod);
-            }
-            else if (devEnv.hot) {
-                devEnv.hot.send({ type: "full-reload" });
-            }
+        if (environment === VITE_ENVIRONMENTS.client && evt.detail.type !== "update") {
+            // Client has to be reloaded when routes are added or removed
+            reloadModule(mod);
+        }
+        else {
+            invalidateModule(mod);
         }
-    }
+    });
 }
 export const fileSystemWatcher = (routers) => {
     const plugin = {
         name: "fs-watcher",
         async configureServer(server) {
-            Object.keys(routers).forEach(environment => {
-                const router = globalThis.ROUTERS[environment];
+            for (const environment of [VITE_ENVIRONMENTS.server, VITE_ENVIRONMENTS.client]) {
+                const router = routers[environment];
                 setupWatcher(server.watcher, router);
                 createRoutesReloader(server, router, environment);
-            });
+            }
         },
     };
     return plugin;

package/dist/config/fs-routes/router.d.ts

@@ -10,6 +10,10 @@ type Route = {
 } & Record<string, any>;
 export declare function cleanPath(src: string, config: FileSystemRouterConfig): string;
 export declare function analyzeModule(src: string): readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean, hasModuleSyntax: boolean];
+type RouterEvent = CustomEvent<{
+    route: string;
+    type: "update" | "remove" | "add";
+}>;
 export declare class BaseFileSystemRouter extends EventTarget {
     routes: Route[];
     config: FileSystemRouterConfig;
@@ -27,11 +31,12 @@ export declare class BaseFileSystemRouter extends EventTarget {
      * To be attached by vite plugin to the vite dev server
      */
     update: undefined;
-    _addRoute(route: Route): void;
+    _addRoute(route: Route): boolean;
     addRoute(src: string): Promise<void>;
-    reload(route: string): void;
-    updateRoute(src: string): Promise<void>;
+    reload(route: string, type: "update" | "remove" | "add"): void;
+    updateRoute(src_: string): Promise<void>;
     removeRoute(src: string): void;
+    on(type: string, cb: (evt: RouterEvent) => void): () => void;
     buildRoutesPromise?: Promise<any[]>;
     getRoutes(): Promise<Route[]>;
 }

package/dist/config/fs-routes/router.js

@@ -71,8 +71,11 @@ export class BaseFileSystemRouter extends EventTarget {
      */
     update = undefined;
     _addRoute(route) {
-        this.routes = this.routes.filter(r => r.path !== route.path);
+        const idx = this.routes.findIndex(r => r.path === route.path);
+        if (idx >= 0)
+            this.routes.splice(idx, 1);
         this.routes.push(route);
+        return idx >= 0;
     }
     async addRoute(src) {
         src = normalizePath(src);
@@ -81,7 +84,7 @@ export class BaseFileSystemRouter extends EventTarget {
                 const route = this.toRoute(src);
                 if (route) {
                     this._addRoute(route);
-                    this.reload(route.path);
+                    this.reload(route.path, "add");
                 }
             }
             catch (e) {
@@ -89,22 +92,25 @@ export class BaseFileSystemRouter extends EventTarget {
             }
         }
     }
-    reload(route) {
-        this.dispatchEvent(new Event("reload", {
-            // @ts-ignore
+    reload(route, type) {
+        this.dispatchEvent(new CustomEvent("reload", {
             detail: {
                 route,
+                type,
             },
         }));
     }
-    async updateRoute(src) {
-        src = normalizePath(src);
+    async updateRoute(src_) {
+        const src = normalizePath(src_);
         if (this.isRoute(src)) {
             try {
                 const route = this.toRoute(src);
                 if (route) {
-                    this._addRoute(route);
-                    this.reload(route.path);
+                    const updated = this._addRoute(route);
+                    this.reload(route.path, updated ? "update" : "add");
+                }
+                else {
+                    this.removeRoute(src_);
                 }
             }
             catch (e) {
@@ -120,10 +126,17 @@ export class BaseFileSystemRouter extends EventTarget {
             if (path === undefined) {
                 return;
             }
-            this.routes = this.routes.filter(r => r.path !== path);
-            this.dispatchEvent(new Event("reload", {}));
+            const idx = this.routes.findIndex(r => r.path === path);
+            if (idx === -1)
+                return;
+            this.routes.splice(idx, 1);
+            this.reload(path, "remove");
         }
     }
+    on(type, cb) {
+        this.addEventListener(type, cb);
+        return () => this.removeEventListener(type, cb);
+    }
     buildRoutesPromise;
     async getRoutes() {
         if (!this.buildRoutesPromise) {

package/dist/config/fs-routes/tree-shake.js

@@ -260,9 +260,6 @@ function treeShakeTransform({ types: t }) {
     };
 }
 export function treeShake() {
-    let config;
-    const cache = {};
-    let server;
     async function transform(id, code) {
         const [path, queryString] = id.split("?");
         const query = new URLSearchParams(queryString);
@@ -286,44 +283,6 @@ export function treeShake() {
     return {
         name: "tree-shake",
         enforce: "pre",
-        configResolved(resolvedConfig) {
-            config = resolvedConfig;
-        },
-        configureServer(s) {
-            server = s;
-        },
-        async handleHotUpdate(ctx) {
-            if (cache[ctx.file]) {
-                const mods = [];
-                const newCode = await ctx.read();
-                for (const [id, code] of Object.entries(cache[ctx.file])) {
-                    const transformed = await transform(id, newCode);
-                    if (!transformed)
-                        continue;
-                    const { code: transformedCode } = transformed;
-                    if (transformedCode !== code) {
-                        const mod = server.moduleGraph.getModuleById(id);
-                        if (mod)
-                            mods.push(mod);
-                    }
-                    cache[ctx.file] ??= {};
-                    cache[ctx.file][id] = transformedCode;
-                    // server.moduleGraph.setModuleSource(id, code);
-                }
-                return mods;
-            }
-            // 	const mods = [];
-            // 	[...server.moduleGraph.urlToModuleMap.entries()].forEach(([url, m]) => {
-            // 		if (m.file === ctx.file && m.id.includes("pick=")) {
-            // 			if (!m.id.includes("pick=loader")) {
-            // 				mods.push(m);
-            // 			}
-            // 		}
-            // 	});
-            // 	return mods;
-            // 	// this.router.updateRoute(ctx.path);
-            // }
-        },
         async transform(code, id) {
             const [path, queryString] = id.split("?");
             if (!path)
@@ -336,8 +295,6 @@ export function treeShake() {
                 const transformed = await transform(id, code);
                 if (!transformed?.code)
                     return;
-                cache[path] ??= {};
-                cache[path][id] = transformed.code;
                 return {
                     code: transformed.code,
                     map: transformed.map,

package/dist/config/index.js

@@ -37,6 +37,18 @@ export function solidStart(options) {
         server: `${start.appRoot}/entry-server${entryExtension}`,
     };
     return [
+        // TODO (Alexis): check if the comment below is still relevant
+        //
+        // Must be placed after fsRoutes, as treeShake will remove the
+        // server fn exports added in by this plugin
+        serverFunctionsPlugin({
+            manifest: VIRTUAL_MODULES.serverFnManifest,
+            runtime: {
+                server: '@solidjs/start/fns/server',
+                client: '@solidjs/start/fns/client',
+            },
+            filter: options?.serverFunctions?.filter,
+        }),
         {
             name: "solid-start:config",
             enforce: "pre",
@@ -166,16 +178,6 @@ export function solidStart(options) {
         }),
         lazy(),
         envPlugin(options?.env),
-        // Must be placed after fsRoutes, as treeShake will remove the
-        // server fn exports added in by this plugin
-        serverFunctionsPlugin({
-            manifest: VIRTUAL_MODULES.serverFnManifest,
-            runtime: {
-                server: '@solidjs/start/fns/server',
-                client: '@solidjs/start/fns/client',
-            },
-            filter: options?.serverFunctions?.filter,
-        }),
         {
             name: "solid-start:virtual-modules",
             async resolveId(id) {

package/dist/config/lazy.js

@@ -77,6 +77,8 @@ const lazy = () => {
             // Therefore we skip, if the src doesn't have any import
             if (src.indexOf("import") === -1)
                 return;
+            if (id.includes("entry-server"))
+                return;
             const plugins = [];
             const hasDefaultExport = src.indexOf("export default") !== -1;
             if (hasDefaultExport) {

package/dist/config/manifest.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { version as viteVersion } from "vite";
+import { fileURLToPath } from "node:url";
 import { findStylesInModuleGraph } from "../server/collect-styles.js";
 import { VIRTUAL_MODULES } from "./constants.js";
 import { wrapId } from "./vite-utils.js";
@@ -16,11 +17,11 @@ export function manifest(start) {
             if (id === VIRTUAL_MODULES.clientViteManifest)
                 return `\0${VIRTUAL_MODULES.clientViteManifest}`;
             if (id === VIRTUAL_MODULES.getClientManifest)
-                return this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname);
+                return this.resolve(fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)));
             if (id === VIRTUAL_MODULES.getManifest) {
                 return this.environment.config.consumer === "client"
-                    ? this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname)
-                    : this.resolve(new URL("../server/manifest/ssr-manifest", import.meta.url).pathname);
+                    ? this.resolve(fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)))
+                    : this.resolve(fileURLToPath(new URL("../server/manifest/ssr-manifest", import.meta.url)));
             }
             if (id === VIRTUAL_MODULES.middleware) {
                 if (start.middleware)

package/dist/directives/index.js

@@ -140,6 +140,7 @@ export function serverFunctionsPlugin(options) {
         },
         {
             name: "solid-start:server-functions/compiler",
+            enforce: 'pre',
             async transform(code, fileId, opts) {
                 const mode = opts?.ssr ? "server" : "client";
                 const [id] = fileId.split("?");

package/dist/directives/remove-unused-variables.js

@@ -1,5 +1,17 @@
 import * as t from "@babel/types";
 import { isPathValid } from "./paths.js";
+function isInvalidForRemoval(path) {
+    if (isPathValid(path, t.isCatchClause)) {
+        // This case is for `catch (error)` blocks
+        return true;
+    }
+    // This one is for destructured variables
+    let target = path;
+    if (isPathValid(path, t.isVariableDeclarator)) {
+        target = path.get('id');
+    }
+    return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
+}
 export function removeUnusedVariables(program) {
     // TODO(Alexis):
     // This implementation is simple but slow
@@ -20,19 +32,20 @@ export function removeUnusedVariables(program) {
                         case "hoisted":
                         case "module":
                             if (binding.references === 0 && !binding.path.removed) {
-                                if (isPathValid(binding.path.parentPath, t.isImportDeclaration)) {
-                                    const parent = binding.path.parentPath;
+                                const parent = binding.path.parentPath;
+                                if (isPathValid(parent, t.isImportDeclaration)) {
                                     if (parent.node.specifiers.length === 1) {
                                         parent.remove();
                                     }
                                     else {
                                         binding.path.remove();
                                     }
+                                    dirty = true;
                                 }
-                                else {
+                                else if (!(isInvalidForRemoval(binding.path))) {
                                     binding.path.remove();
+                                    dirty = true;
                                 }
-                                dirty = true;
                             }
                             break;
                         case "local":

package/dist/server/handler.d.ts

@@ -1,4 +1,4 @@
-import { type H3Event } from "h3";
+import { type H3Event } from "h3/generic";
 import type { JSX } from "solid-js";
 import type { FetchEvent, HandlerOptions, PageEvent } from "./types.ts";
 export declare function createBaseHandler(createPageEvent: (e: FetchEvent) => Promise<PageEvent>, fn: (context: PageEvent) => JSX.Element, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>)): {

package/dist/server/handler.js

@@ -1,5 +1,5 @@
 import middleware from "solid-start:middleware";
-import { defineHandler, getCookie, H3, redirect, setCookie } from "h3";
+import { defineHandler, getCookie, H3, redirect, setCookie } from "h3/generic";
 import { sharedConfig } from "solid-js";
 import { getRequestEvent, renderToStream, renderToString } from "solid-js/web";
 import { createRoutes } from "../router.jsx";

package/dist/utils/debounce.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Creates a debounced function that delays the invocation of a function
+ */
+export declare const debounce: <T extends (...args: any[]) => void>(cb: T, debounceMs: number) => (...args: Parameters<T>) => void;

package/dist/utils/debounce.js

@@ -0,0 +1,10 @@
+/**
+ * Creates a debounced function that delays the invocation of a function
+ */
+export const debounce = (cb, debounceMs) => {
+    let timeout;
+    return (...args) => {
+        clearTimeout(timeout);
+        timeout = setTimeout(() => cb(...args), debounceMs);
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-beta.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -62,7 +62,7 @@
     "vitest": "^4.1.0"
   },
   "peerDependencies": {
-    "vite": "^7"
+    "vite": "^7 || ^8"
   },
   "scripts": {
     "build": "pnpm validate-imports && tsc && node scripts/build.js",

package/src/config/constants.ts

@@ -14,6 +14,6 @@ export const VIRTUAL_MODULES = {
 } as const;
 
 export const VITE_ENVIRONMENTS = {
-  client: "client",
-  server: "ssr",
+  client: "client" as const,
+  server: "ssr" as const,
 };

package/src/config/fs-routes/fs-watcher.ts

@@ -1,22 +1,10 @@
-import type {
-  EnvironmentModuleNode,
-  FSWatcher,
-  PluginOption,
-  ViteDevServer,
-} from "vite";
+import type { EnvironmentModuleNode, FSWatcher, PluginOption, ViteDevServer } from "vite";
+import { debounce } from "../../utils/debounce.ts";
 import { VITE_ENVIRONMENTS } from "../constants.ts";
 import { moduleId } from "./index.ts";
 import type { BaseFileSystemRouter } from "./router.ts";
 
-interface CompiledRouter {
-  removeRoute(path: string): void;
-  addRoute(path: string): void;
-  updateRoute(path: string): void;
-  addEventListener(event: "reload", handler: () => void): void;
-  removeEventListener(event: "reload", handler: () => void): void;
-}
-
-function setupWatcher(watcher: FSWatcher, routes: CompiledRouter): void {
+function setupWatcher(watcher: FSWatcher, routes: BaseFileSystemRouter): void {
   watcher.on("unlink", path => routes.removeRoute(path));
   watcher.on("add", path => routes.addRoute(path));
   watcher.on("change", path => routes.updateRoute(path));
@@ -24,33 +12,41 @@ function setupWatcher(watcher: FSWatcher, routes: CompiledRouter): void {
 
 function createRoutesReloader(
   server: ViteDevServer,
-  routes: CompiledRouter,
+  routes: BaseFileSystemRouter,
   environment: "client" | "ssr",
-): () => void {
-  routes.addEventListener("reload", handleRoutesReload);
-  return () => routes.removeEventListener("reload", handleRoutesReload);
+) {
+  const devEnv = server.environments[environment]!;
+  if (!devEnv?.moduleGraph) return;
+
+  /**
+   * Debounce catches multiple route changes in a row
+   * Short timeout for inexpensive invalidations
+   */
+  const invalidateModule = debounce((mod: EnvironmentModuleNode) => {
+    devEnv.moduleGraph.invalidateModule(mod);
+  }, 0);
 
-  function handleRoutesReload(): void {
-    const envName =
-      environment === "ssr" ? VITE_ENVIRONMENTS.server : VITE_ENVIRONMENTS.client;
-    const devEnv = server.environments[envName];
-    if (!devEnv?.moduleGraph) return;
+  /**
+   * Long debounce timeout for expensive reloads
+   */
+  const reloadModule = debounce((mod: EnvironmentModuleNode) => {
+    devEnv.reloadModule(mod);
+  }, 200);
 
-    const mod: EnvironmentModuleNode | undefined =
-      devEnv.moduleGraph.getModuleById(moduleId);
-    if (mod) {
-      const seen = new Set<EnvironmentModuleNode>();
-      devEnv.moduleGraph.invalidateModule(mod, seen);
+  return routes.on("reload", function handleRoutesReload(evt): void {
+    const mod = devEnv.moduleGraph.getModuleById(moduleId)!;
+    if (!mod) {
+      devEnv.hot.send({ type: "full-reload" });
+      return;
     }
 
-    if (environment !== "ssr") {
-      if (mod) {
-        devEnv.reloadModule(mod);
-      } else if (devEnv.hot) {
-        devEnv.hot.send({ type: "full-reload" });
-      }
+    if (environment === VITE_ENVIRONMENTS.client && evt.detail.type !== "update") {
+      // Client has to be reloaded when routes are added or removed
+      reloadModule(mod);
+    } else {
+      invalidateModule(mod);
     }
-  }
+  });
 }
 
 export const fileSystemWatcher = (
@@ -59,11 +55,11 @@ export const fileSystemWatcher = (
   const plugin: PluginOption = {
     name: "fs-watcher",
     async configureServer(server: ViteDevServer) {
-      Object.keys(routers).forEach(environment => {
-        const router = (globalThis as any).ROUTERS[environment];
+      for (const environment of [VITE_ENVIRONMENTS.server, VITE_ENVIRONMENTS.client]) {
+        const router = routers[environment];
         setupWatcher(server.watcher, router);
-        createRoutesReloader(server, router, environment as keyof typeof routers);
-      });
+        createRoutesReloader(server, router, environment);
+      }
     },
   };
   return plugin;

package/src/config/fs-routes/router.ts

@@ -32,6 +32,8 @@ export function analyzeModule(src: string) {
   );
 }
 
+type RouterEvent = CustomEvent<{ route: string; type: "update" | "remove" | "add" }>;
+
 export class BaseFileSystemRouter extends EventTarget {
   routes: Route[];
 
@@ -98,8 +100,11 @@ export class BaseFileSystemRouter extends EventTarget {
   update = undefined;
 
   _addRoute(route: Route) {
-    this.routes = this.routes.filter(r => r.path !== route.path);
+    const idx = this.routes.findIndex(r => r.path === route.path);
+    if (idx >= 0) this.routes.splice(idx, 1);
     this.routes.push(route);
+
+    return idx >= 0;
   }
 
   async addRoute(src: string) {
@@ -109,7 +114,7 @@ export class BaseFileSystemRouter extends EventTarget {
         const route = this.toRoute(src);
         if (route) {
           this._addRoute(route);
-          this.reload(route.path);
+          this.reload(route.path, "add");
         }
       } catch (e) {
         console.error(e);
@@ -117,25 +122,27 @@ export class BaseFileSystemRouter extends EventTarget {
     }
   }
 
-  reload(route: string) {
+  reload(route: string, type: "update" | "remove" | "add") {
     this.dispatchEvent(
-      new Event("reload", {
-        // @ts-ignore
+      new CustomEvent("reload", {
         detail: {
           route,
+          type,
         },
       }),
     );
   }
 
-  async updateRoute(src: string) {
-    src = normalizePath(src);
+  async updateRoute(src_: string) {
+    const src = normalizePath(src_);
     if (this.isRoute(src)) {
       try {
         const route = this.toRoute(src);
         if (route) {
-          this._addRoute(route);
-          this.reload(route.path);
+          const updated = this._addRoute(route);
+          this.reload(route.path, updated ? "update" : "add");
+        } else {
+          this.removeRoute(src_);
         }
       } catch (e) {
         console.error(e);
@@ -151,11 +158,20 @@ export class BaseFileSystemRouter extends EventTarget {
       if (path === undefined) {
         return;
       }
-      this.routes = this.routes.filter(r => r.path !== path);
-      this.dispatchEvent(new Event("reload", {}));
+
+      const idx = this.routes.findIndex(r => r.path === path);
+      if (idx === -1) return;
+
+      this.routes.splice(idx, 1);
+      this.reload(path, "remove");
     }
   }
 
+  on(type: string, cb: (evt: RouterEvent) => void) {
+    this.addEventListener(type, cb as any);
+    return () => this.removeEventListener(type, cb as any);
+  }
+
   buildRoutesPromise?: Promise<any[]>;
 
   async getRoutes() {

package/src/config/fs-routes/tree-shake.ts

@@ -6,7 +6,7 @@ import type * as Babel from "@babel/core";
 import type { NodePath, PluginObj, PluginPass } from "@babel/core";
 import type { Binding } from "@babel/traverse";
 import { basename } from "pathe";
-import type { Plugin, ResolvedConfig, ViteDevServer } from "vite";
+import type { Plugin } from "vite";
 
 type State = Omit<PluginPass, "opts"> & {
   opts: { pick: string[] };
@@ -280,10 +280,6 @@ function treeShakeTransform({ types: t }: typeof Babel): PluginObj<State> {
 }
 
 export function treeShake(): Plugin {
-  let config: ResolvedConfig;
-  const cache: Record<string, any> = {};
-  let server: ViteDevServer;
-
   async function transform(id: string, code: string) {
     const [path, queryString] = id.split("?");
     const query = new URLSearchParams(queryString);
@@ -308,46 +304,6 @@ export function treeShake(): Plugin {
   return {
     name: "tree-shake",
     enforce: "pre",
-    configResolved(resolvedConfig) {
-      config = resolvedConfig;
-    },
-    configureServer(s) {
-      server = s;
-    },
-    async handleHotUpdate(ctx) {
-      if (cache[ctx.file]) {
-        const mods = [];
-        const newCode = await ctx.read();
-        for (const [id, code] of Object.entries(cache[ctx.file])) {
-          const transformed = await transform(id, newCode);
-          if (!transformed) continue;
-
-          const { code: transformedCode } = transformed;
-
-          if (transformedCode !== code) {
-            const mod = server.moduleGraph.getModuleById(id);
-            if (mod) mods.push(mod);
-          }
-
-          cache[ctx.file] ??= {};
-          cache[ctx.file][id] = transformedCode;
-          // server.moduleGraph.setModuleSource(id, code);
-        }
-
-        return mods;
-      }
-      // 	const mods = [];
-      // 	[...server.moduleGraph.urlToModuleMap.entries()].forEach(([url, m]) => {
-      // 		if (m.file === ctx.file && m.id.includes("pick=")) {
-      // 			if (!m.id.includes("pick=loader")) {
-      // 				mods.push(m);
-      // 			}
-      // 		}
-      // 	});
-      // 	return mods;
-      // 	// this.router.updateRoute(ctx.path);
-      // }
-    },
     async transform(code, id) {
       const [path, queryString] = id.split("?");
       if (!path) return;
@@ -358,9 +314,6 @@ export function treeShake(): Plugin {
         const transformed = await transform(id, code);
         if (!transformed?.code) return;
 
-        cache[path] ??= {};
-        cache[path][id] = transformed.code;
-
         return {
           code: transformed.code,
           map: transformed.map,

package/src/config/index.ts

@@ -63,6 +63,18 @@ export function solidStart(options?: SolidStartOptions): Array<PluginOption> {
     server: `${start.appRoot}/entry-server${entryExtension}`,
   };
   return [
+    // TODO (Alexis): check if the comment below is still relevant
+    //
+    // Must be placed after fsRoutes, as treeShake will remove the
+    // server fn exports added in by this plugin
+    serverFunctionsPlugin({
+      manifest: VIRTUAL_MODULES.serverFnManifest,
+      runtime: {
+        server: '@solidjs/start/fns/server',
+        client: '@solidjs/start/fns/client',
+      },
+      filter: options?.serverFunctions?.filter,
+    }),
     {
       name: "solid-start:config",
       enforce: "pre",
@@ -190,16 +202,6 @@ export function solidStart(options?: SolidStartOptions): Array<PluginOption> {
     }),
     lazy(),
     envPlugin(options?.env),
-    // Must be placed after fsRoutes, as treeShake will remove the
-    // server fn exports added in by this plugin
-    serverFunctionsPlugin({
-      manifest: VIRTUAL_MODULES.serverFnManifest,
-      runtime: {
-        server: '@solidjs/start/fns/server',
-        client: '@solidjs/start/fns/client',
-      },
-      filter: options?.serverFunctions?.filter,
-    }),
     {
       name: "solid-start:virtual-modules",
       async resolveId(id) {

package/src/config/lazy.ts

@@ -90,6 +90,7 @@ const lazy = (): PluginOption => {
       // The transformed files either import "lazy" or css files
       // Therefore we skip, if the src doesn't have any import
       if (src.indexOf("import") === -1) return;
+      if (id.includes("entry-server")) return;
 
       const plugins: PluginItem[] = [];
 

package/src/config/manifest.ts

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { type PluginOption, type ViteDevServer, version as viteVersion } from "vite";
+import { fileURLToPath } from "node:url";
 
 import { findStylesInModuleGraph } from "../server/collect-styles.ts";
 import { VIRTUAL_MODULES } from "./constants.ts";
@@ -20,12 +21,16 @@ export function manifest(start: SolidStartOptions): PluginOption {
         return `\0${VIRTUAL_MODULES.clientViteManifest}`;
       if (id === VIRTUAL_MODULES.getClientManifest)
         return this.resolve(
-          new URL("../server/manifest/client-manifest", import.meta.url).pathname,
+          fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)),
         );
       if (id === VIRTUAL_MODULES.getManifest) {
         return this.environment.config.consumer === "client"
-          ? this.resolve(new URL("../server/manifest/client-manifest", import.meta.url).pathname)
-          : this.resolve(new URL("../server/manifest/ssr-manifest", import.meta.url).pathname);
+          ? this.resolve(
+              fileURLToPath(new URL("../server/manifest/client-manifest", import.meta.url)),
+            )
+          : this.resolve(
+              fileURLToPath(new URL("../server/manifest/ssr-manifest", import.meta.url)),
+            );
       }
       if (id === VIRTUAL_MODULES.middleware) {
         if (start.middleware) return await this.resolve(start.middleware);

package/src/directives/index.ts

@@ -196,6 +196,7 @@ export function serverFunctionsPlugin(options: ServerFunctionsOptions): Plugin[]
     },
     {
       name: "solid-start:server-functions/compiler",
+      enforce: 'pre',
       async transform(code, fileId, opts) {
         const mode = opts?.ssr ? "server" : "client";
         const [id] = fileId.split("?");

package/src/directives/remove-unused-variables.ts

@@ -2,6 +2,20 @@ import type * as babel from "@babel/core";
 import * as t from "@babel/types";
 import { isPathValid } from "./paths.ts";
 
+function isInvalidForRemoval(path: babel.NodePath) {
+  if (isPathValid(path, t.isCatchClause)) {
+    // This case is for `catch (error)` blocks
+    return true;
+  }
+
+  // This one is for destructured variables
+  let target = path;
+  if (isPathValid(path, t.isVariableDeclarator)) {
+    target = path.get('id');
+  }
+  return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
+}
+
 export function removeUnusedVariables(program: babel.NodePath<t.Program>) {
   // TODO(Alexis):
   // This implementation is simple but slow
@@ -24,17 +38,18 @@ export function removeUnusedVariables(program: babel.NodePath<t.Program>) {
             case "hoisted":
             case "module":
               if (binding.references === 0 && !binding.path.removed) {
-                if (isPathValid(binding.path.parentPath, t.isImportDeclaration)) {
                   const parent = binding.path.parentPath;
+                if (isPathValid(parent, t.isImportDeclaration)) {
                   if (parent.node.specifiers.length === 1) {
                     parent.remove();
                   } else {
                     binding.path.remove();
                   }
-                } else {
+                  dirty = true;
+                } else if (!(isInvalidForRemoval(binding.path))) {
                   binding.path.remove();
+                  dirty = true;
                 }
-                dirty = true;
               }
               break;
             case "local":

package/src/server/handler.ts

@@ -1,5 +1,5 @@
 import middleware from "solid-start:middleware";
-import { defineHandler, getCookie, H3, type H3Event, redirect, setCookie } from "h3";
+import { defineHandler, getCookie, H3, type H3Event, redirect, setCookie } from "h3/generic";
 import { join } from "pathe";
 import type { JSX } from "solid-js";
 import { sharedConfig } from "solid-js";

package/src/utils/debounce.ts

@@ -0,0 +1,10 @@
+/**
+ * Creates a debounced function that delays the invocation of a function
+ */
+export const debounce = <T extends (...args: any[]) => void>(cb: T, debounceMs: number) => {
+  let timeout: NodeJS.Timeout | undefined;
+  return (...args: Parameters<T>) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => cb(...args), debounceMs)
+  }
+}