@solidjs/start 1.1.7 → 1.2.1

package/README.md

@@ -1,12 +1,92 @@
-# Solid Start
+<div align="center">
 
-This is the SolidStart framework and CLI.
+[![Banner](https://assets.solidjs.com/banner?project=Start&type=core)](https://github.com/solidjs)
 
-The quickest way to get started:
+[![Version](https://img.shields.io/npm/v/@solidjs/start.svg?style=for-the-badge&color=blue&logo=npm)](https://npmjs.com/package/@solidjs/start)
+[![Downloads](https://img.shields.io/npm/dm/@solidjs/start.svg?style=for-the-badge&color=green&logo=npm)](https://npmjs.com/package/@solidjs/start)
+[![Stars](https://img.shields.io/github/stars/solidjs/solid-start?style=for-the-badge&color=yellow&logo=github)](https://github.com/solidjs/solid-start)
+[![Discord](https://img.shields.io/discord/722131463138705510?label=join&style=for-the-badge&color=5865F2&logo=discord&logoColor=white)](https://discord.com/invite/solidjs)
+[![Reddit](https://img.shields.io/reddit/subreddit-subscribers/solidjs?label=join&style=for-the-badge&color=FF4500&logo=reddit&logoColor=white)](https://reddit.com/r/solidjs)
+
+</div>
+
+**SolidStart** brings fine-grained reactivity fullstack with full flexibility. Built with features like unified rendering and isomorphic code execution, SolidStart enables you to create highly performant and scalable web applications.
+
+Explore the official [documentation](https://docs.solidjs.com/solid-start) for detailed guides and examples.
+
+## Core Features
+
+- **All Rendering Modes**:
+  - Server-Side Rendering _(SSR)_ with sync, async, and stream [modes](https://docs.solidjs.com/solid-start/reference/server/create-handler)
+  - Client-Side Rendering _(CSR)_ with the possibility of being page/component [scoped](https://docs.solidjs.com/solid-start/reference/client/client-only)
+  - Static Site Generation _(SSG)_ with route [pre-rendering](https://docs.solidjs.com/solid-start/building-your-application/route-prerendering)
+- **TypeScript**: Full integration for robust, type-safe development
+- **File-Based Routing**: Intuitive routing based on your project’s file structure
+- **API Routes**: Dedicated server-side endpoints for seamless API development
+- **Streaming**: Efficient data rendering for faster page loads
+- **Build Optimizations**: Code splitting, tree shaking, and dead code elimination
+- **Deployment Adapters**: Easily deploy to platforms like Vercel, Netlify, Cloudflare, and more
+
+## Getting Started
+
+### Installation
+
+Create a SolidStart template project with your preferred package manager
+
+```bash
+# using npm
+npm create solid@latest -- -s
+```
 
 ```bash
-npm init solid@latest my-app
-cd my-app
-npm install
-npm run dev
-```
+# using pnpm
+pnpm create solid@latest -s
+```
+
+```bash
+# using bun
+bun create solid@latest --s
+```
+
+### Project Structure
+
+- `public/`: Static assets like icons, images, and fonts
+- `src/`: Core application (aliased to `~/`)
+  - `routes/`: File-based routing for pages and APIs
+  - `app.tsx`: Root component of your application
+  - `entry-client.tsx`: Handles client-side hydration
+  - `entry-server.tsx`: Manages server-side request handling
+- **Configuration Files**: `app.config.ts`, `package.json`, and more
+
+Learn more about [routing](https://docs.solidjs.com/solid-start/building-your-application/routing)
+
+## Adapters
+
+Configure adapters in `app.config.ts` to deploy to platforms like Vercel, Netlify, Cloudflare, and others
+
+```ts
+import { defineConfig } from "@solidjs/start/config";
+
+export default defineConfig({
+  ssr: true, // false for client-side rendering only
+  server: { preset: "netlify" },
+});
+```
+
+Presets also include runtimes like Node.js, Bun or Deno. For example, a preset like `node-server` enables hosting on your server.  
+Learn more about [`defineConfig`](https://docs.solidjs.com/solid-start/reference/config/define-config)
+
+## Building
+
+Generate production-ready bundles
+
+```bash
+npm run build # or pnpm build or bun build
+```
+
+After the build completes, you’ll be guided through deployment for your specific preset.
+
+## Contributing
+
+- For contributing to the codebase, check [CONTRIBUTING.md](https://github.com/solidjs/solid-start/blob/main/CONTRIBUTING.md)
+- For creating a new template, please head on to [solidjs/templates](https://github.com/solidjs/templates)

package/config/fs-router.js

@@ -1,4 +1,4 @@
-import { analyzeModule, BaseFileSystemRouter, cleanPath } from "vinxi/fs-router";
+import {analyzeModule, BaseFileSystemRouter, cleanPath} from "vinxi/fs-router";
 
 export class SolidStartClientFileRouter extends BaseFileSystemRouter {
   toPath(src) {
@@ -43,13 +43,13 @@ export class SolidStartClientFileRouter extends BaseFileSystemRouter {
         page: true,
         $component: {
           src: src,
-          pick: ["default", "$css"]
+          pick: [...exports.filter(e => e.n === e.ln && e.n !== "route").map(e => e.n), "default", "$css"]
         },
         $$route: hasRouteConfig
           ? {
-              src: src,
-              pick: ["route"]
-            }
+            src: src,
+            pick: ["route"]
+          }
           : undefined,
         path,
         filePath: src
@@ -123,15 +123,15 @@ export class SolidStartServerFileRouter extends BaseFileSystemRouter {
         $component:
           !this.config.dataOnly && hasDefault
             ? {
-                src: src,
-                pick: ["default", "$css"]
-              }
+              src: src,
+              pick: [...exports.filter(e => e.n === e.ln && e.n !== "route" && !HTTP_METHODS.includes(e.n)).map(e => e.n), "default", "$css"]
+            }
             : undefined,
         $$route: hasRouteConfig
           ? {
-              src: src,
-              pick: ["route"]
-            }
+            src: src,
+            pick: ["route"]
+          }
           : undefined,
         ...createHTTPHandlers(src, exports),
         path,

package/config/index.d.ts

@@ -14,6 +14,7 @@ type ViteCustomizableConfig = CustomizableConfig & {
 };
 
 type SolidStartInlineConfig = {
+  publicDir?: string;
   ssr?: boolean;
   solid?: Options;
   extensions?: string[];

package/config/index.js

@@ -71,6 +71,7 @@ export function defineConfig(baseConfig = {}) {
   let { vite = {}, ...start } = baseConfig;
   const extensions = [...DEFAULT_EXTENSIONS, ...(start.extensions || [])];
   start = defu(start, {
+    publicDir: "./public",
     appRoot: "./src",
     routeDir: "./routes",
     ssr: true,
@@ -110,7 +111,7 @@ export function defineConfig(baseConfig = {}) {
         name: "public",
         type: "static",
         base: "/",
-        dir: "./public"
+        dir: start.publicDir
       },
       {
         name: "ssr",

package/dist/middleware/index.d.ts

@@ -12,7 +12,7 @@ export declare function createMiddleware({ onRequest, onBeforeResponse }: {
     onRequest?: RequestMiddleware | RequestMiddleware[] | undefined;
     onBeforeResponse?: ResponseMiddleware | ResponseMiddleware[] | undefined;
 }): {
-    onRequest?: import("h3")._RequestMiddleware | import("h3")._RequestMiddleware[] | undefined;
-    onBeforeResponse?: import("h3")._ResponseMiddleware | import("h3")._ResponseMiddleware[] | undefined;
+    onRequest?: import("vinxi/http")._RequestMiddleware | import("vinxi/http")._RequestMiddleware[] | undefined;
+    onBeforeResponse?: import("vinxi/http")._ResponseMiddleware | import("vinxi/http")._ResponseMiddleware[] | undefined;
 };
 export {};

package/dist/router/routes.d.ts

@@ -23,5 +23,6 @@ export declare const pageRoutes: Route[];
 export declare function matchAPIRoute(path: string, method: string): {
     handler: any;
     params: Record<string, any> | undefined;
+    isPage: boolean;
 } | undefined;
 export {};

package/dist/router/routes.js

@@ -26,14 +26,23 @@ function defineRoutes(fileRoutes) {
 export function matchAPIRoute(path, method) {
     const match = router.lookup(path);
     if (match && match.route) {
-        const handler = method === "HEAD" ? match.route["$HEAD"] || match.route["$GET"] : match.route[`$${method}`];
+        const route = match.route;
+        // Find the appropriate handler for the HTTP method
+        const handler = method === "HEAD"
+            ? route.$HEAD || route.$GET
+            : route[`$${method}`];
         if (handler === undefined)
             return;
+        // Check if this is a page route
+        const isPage = route.page === true && route.$component !== undefined;
+        // Return comprehensive route information
         return {
             handler,
-            params: match.params
+            params: match.params,
+            isPage
         };
     }
+    return undefined;
 }
 function containsHTTP(route) {
     return (route["$HEAD"] ||

package/dist/runtime/server-handler.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<unknown>>;
+declare const _default: import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<unknown>>;
 export default _default;

package/dist/runtime/server-handler.js

@@ -1,4 +1,5 @@
 /// <reference types="vinxi/types/server" />
+import { parseSetCookie } from "cookie-es";
 import { crossSerializeStream, fromJSON, getCrossReferenceHeader } from "seroval";
 // @ts-ignore
 import { CustomEventPlugin, DOMExceptionPlugin, EventPlugin, FormDataPlugin, HeadersPlugin, ReadableStreamPlugin, RequestPlugin, ResponsePlugin, URLPlugin, URLSearchParamsPlugin } from "seroval-plugins/web";
@@ -275,9 +276,16 @@ function createSingleFlightHeaders(sourceEvent) {
     SetCookies.forEach(cookie => {
         if (!cookie)
             return;
-        const keyValue = cookie.split(";")[0];
-        const [key, value] = keyValue.split("=");
-        key && value && (cookies[key] = value);
+        const { maxAge, expires, name, value } = parseSetCookie(cookie);
+        if (maxAge != null && maxAge <= 0) {
+            delete cookies[name];
+            return;
+        }
+        if (expires != null && expires.getTime() <= Date.now()) {
+            delete cookies[name];
+            return;
+        }
+        cookies[name] = value;
     });
     Object.entries(cookies).forEach(([key, value]) => {
         headers.append("cookie", `${key}=${value}`);

package/dist/server/fetchEvent.js

@@ -36,7 +36,7 @@ class HeaderProxy {
         return Array.isArray(h) ? h.join(", ") : h || null;
     }
     has(key) {
-        return this.get(key) !== undefined;
+        return this.get(key) !== null;
     }
     set(key, value) {
         return setResponseHeader(this.event, key, value);

package/dist/server/fetchEvent.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/fetchEvent.spec.js

@@ -0,0 +1,244 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { cloneEvent, createFetchEvent, getFetchEvent, mergeResponseHeaders } from "./fetchEvent";
+vi.mock("vinxi/http", () => ({
+    getWebRequest: vi.fn(),
+    getRequestIP: vi.fn(),
+    getResponseStatus: vi.fn(),
+    setResponseStatus: vi.fn(),
+    getResponseStatusText: vi.fn(),
+    getResponseHeader: vi.fn(),
+    getResponseHeaders: vi.fn(),
+    setResponseHeader: vi.fn(),
+    appendResponseHeader: vi.fn(),
+    removeResponseHeader: vi.fn()
+}));
+import * as vinxiHttp from "vinxi/http";
+const mockedVinxiHttp = vi.mocked(vinxiHttp);
+const createMockH3Event = () => {
+    const mockRequest = new Request("http://localhost/test");
+    const mockStatus = 200;
+    const mockStatusText = "OK";
+    return {
+        node: {
+            req: {},
+            res: {
+                statusCode: mockStatus,
+                statusMessage: mockStatusText
+            }
+        },
+        context: {},
+        web: {
+            request: mockRequest
+        }
+    };
+};
+describe("fetchEvent", () => {
+    let mockH3Event;
+    beforeEach(() => {
+        mockH3Event = createMockH3Event();
+        vi.clearAllMocks();
+        mockedVinxiHttp.getWebRequest.mockReturnValue(mockH3Event.web?.request);
+        mockedVinxiHttp.getRequestIP.mockReturnValue("127.0.0.1");
+        mockedVinxiHttp.getResponseStatus.mockReturnValue(200);
+        mockedVinxiHttp.setResponseStatus.mockImplementation(() => { });
+        mockedVinxiHttp.getResponseStatusText.mockReturnValue("OK");
+        mockedVinxiHttp.getResponseHeader.mockReturnValue(undefined);
+        mockedVinxiHttp.getResponseHeaders.mockReturnValue({});
+        mockedVinxiHttp.setResponseHeader.mockImplementation(() => { });
+        mockedVinxiHttp.appendResponseHeader.mockImplementation(() => { });
+        mockedVinxiHttp.removeResponseHeader.mockImplementation(() => { });
+    });
+    describe("createFetchEvent", () => {
+        it("should create a FetchEvent from H3Event", () => {
+            const fetchEvent = createFetchEvent(mockH3Event);
+            expect(fetchEvent).toEqual({
+                request: mockH3Event.web?.request,
+                response: expect.any(Object),
+                clientAddress: "127.0.0.1",
+                locals: {},
+                nativeEvent: mockH3Event
+            });
+        });
+        it("should create response stub with correct properties", () => {
+            const fetchEvent = createFetchEvent(mockH3Event);
+            expect(fetchEvent.response).toHaveProperty("status");
+            expect(fetchEvent.response).toHaveProperty("statusText");
+            expect(fetchEvent.response).toHaveProperty("headers");
+        });
+    });
+    describe("cloneEvent", () => {
+        it("should create a shallow copy of FetchEvent", () => {
+            const original = createFetchEvent(mockH3Event);
+            const cloned = cloneEvent(original);
+            expect(cloned).toEqual(original);
+            expect(cloned).not.toBe(original);
+            expect(cloned.request).toBe(original.request);
+            expect(cloned.response).toBe(original.response);
+        });
+    });
+    describe("getFetchEvent", () => {
+        it("should create and cache FetchEvent on first call", () => {
+            const fetchEvent = getFetchEvent(mockH3Event);
+            expect(mockH3Event.context.solidFetchEvent).toBe(fetchEvent);
+            expect(fetchEvent.nativeEvent).toBe(mockH3Event);
+        });
+        it("should return cached FetchEvent on subsequent calls", () => {
+            const firstCall = getFetchEvent(mockH3Event);
+            const secondCall = getFetchEvent(mockH3Event);
+            expect(firstCall).toBe(secondCall);
+        });
+    });
+    describe("mergeResponseHeaders", () => {
+        it("should merge headers from Headers object to H3Event", () => {
+            const headers = new Headers({
+                "content-type": "application/json",
+                "x-custom": "value"
+            });
+            mergeResponseHeaders(mockH3Event, headers);
+            expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type", "application/json");
+            expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "x-custom", "value");
+        });
+    });
+    describe("ResponseStub", () => {
+        let fetchEvent;
+        beforeEach(() => {
+            fetchEvent = createFetchEvent(mockH3Event);
+        });
+        describe("status", () => {
+            it("should get status from H3Event", () => {
+                expect(fetchEvent.response.status).toBe(200);
+            });
+            it("should set status on H3Event", () => {
+                fetchEvent.response.status = 404;
+                expect(mockedVinxiHttp.setResponseStatus).toHaveBeenCalledWith(mockH3Event, 404);
+            });
+        });
+        describe("statusText", () => {
+            it("should get statusText from H3Event", () => {
+                expect(fetchEvent.response.statusText).toBe("OK");
+            });
+            it("should set statusText on H3Event", () => {
+                fetchEvent.response.statusText = "Not Found";
+                expect(mockedVinxiHttp.setResponseStatus).toHaveBeenCalledWith(mockH3Event, 200, "Not Found");
+            });
+        });
+    });
+    describe("HeaderProxy", () => {
+        let fetchEvent;
+        beforeEach(() => {
+            fetchEvent = createFetchEvent(mockH3Event);
+        });
+        describe("get", () => {
+            it("should return null for non-existent header", () => {
+                expect(fetchEvent.response.headers.get("non-existent")).toBe(null);
+            });
+            it("should return string value for single header", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue("application/json");
+                expect(fetchEvent.response.headers.get("content-type")).toBe("application/json");
+            });
+            it("should join array values with comma", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue(["text/html", "application/json"]);
+                expect(fetchEvent.response.headers.get("accept")).toBe("text/html, application/json");
+            });
+        });
+        describe("has", () => {
+            it("should return false for non-existent header", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue(undefined);
+                expect(fetchEvent.response.headers.has("non-existent")).toBe(false);
+            });
+            it("should return true for existing header", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue("application/json");
+                expect(fetchEvent.response.headers.has("content-type")).toBe(true);
+            });
+        });
+        describe("set", () => {
+            it("should set header value", () => {
+                fetchEvent.response.headers.set("content-type", "application/json");
+                expect(mockedVinxiHttp.setResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type", "application/json");
+            });
+        });
+        describe("delete", () => {
+            it("should remove header", () => {
+                fetchEvent.response.headers.delete("content-type");
+                expect(mockedVinxiHttp.removeResponseHeader).toHaveBeenCalledWith(mockH3Event, "content-type");
+            });
+        });
+        describe("append", () => {
+            it("should append header value", () => {
+                fetchEvent.response.headers.append("x-custom", "value");
+                expect(mockedVinxiHttp.appendResponseHeader).toHaveBeenCalledWith(mockH3Event, "x-custom", "value");
+            });
+        });
+        describe("getSetCookie", () => {
+            it("should return array for single cookie", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue("session=abc123");
+                expect(fetchEvent.response.headers.getSetCookie()).toEqual(["session=abc123"]);
+            });
+            it("should return array for multiple cookies", () => {
+                mockedVinxiHttp.getResponseHeader.mockReturnValue(["session=abc123", "theme=dark"]);
+                expect(fetchEvent.response.headers.getSetCookie()).toEqual([
+                    "session=abc123",
+                    "theme=dark"
+                ]);
+            });
+        });
+        describe("forEach", () => {
+            it("should iterate over headers", () => {
+                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
+                    "content-type": "application/json",
+                    "x-custom": ["value1", "value2"]
+                });
+                const callback = vi.fn();
+                fetchEvent.response.headers.forEach(callback);
+                expect(callback).toHaveBeenCalledWith("application/json", "content-type", expect.any(Object));
+                expect(callback).toHaveBeenCalledWith("value1, value2", "x-custom", expect.any(Object));
+            });
+        });
+        describe("entries", () => {
+            it("should return iterator of header entries", () => {
+                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
+                    "content-type": "application/json",
+                    "x-custom": ["value1", "value2"]
+                });
+                const entries = Array.from(fetchEvent.response.headers.entries());
+                expect(entries).toEqual([
+                    ["content-type", "application/json"],
+                    ["x-custom", "value1, value2"]
+                ]);
+            });
+        });
+        describe("keys", () => {
+            it("should return iterator of header keys", () => {
+                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
+                    "content-type": "application/json",
+                    "x-custom": "value"
+                });
+                const keys = Array.from(fetchEvent.response.headers.keys());
+                expect(keys).toEqual(["content-type", "x-custom"]);
+            });
+        });
+        describe("values", () => {
+            it("should return iterator of header values", () => {
+                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
+                    "content-type": "application/json",
+                    "x-custom": ["value1", "value2"]
+                });
+                const values = Array.from(fetchEvent.response.headers.values());
+                expect(values).toEqual(["application/json", "value1, value2"]);
+            });
+        });
+        describe("Symbol.iterator", () => {
+            it("should be iterable", () => {
+                mockedVinxiHttp.getResponseHeaders.mockReturnValue({
+                    "content-type": "application/json",
+                    "x-custom": "value"
+                });
+                const entries = Array.from(fetchEvent.response.headers);
+                expect(entries).toEqual([
+                    ["content-type", "application/json"],
+                    ["x-custom", "value"]
+                ]);
+            });
+        });
+    });
+});

package/dist/server/handler.d.ts

@@ -4,9 +4,9 @@ import type { FetchEvent, HandlerOptions, PageEvent, ResponseStub } from "./type
  * If not, falls back to the 302 (temporary redirect)
  */
 export declare function getExpectedRedirectStatus(response: ResponseStub): number;
-export declare function createBaseHandler(fn: (context: PageEvent) => unknown, createPageEvent: (event: FetchEvent) => Promise<PageEvent>, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function createBaseHandler(fn: (context: PageEvent) => unknown, createPageEvent: (event: FetchEvent) => Promise<PageEvent>, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<any>>;
 /**
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>), routerLoad?: (event: FetchEvent) => Promise<void>): import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<any>>;

package/dist/server/handler.js

@@ -39,6 +39,8 @@ export function createBaseHandler(fn, createPageEvent, options = {}, routerLoad)
                     if (event.request.method !== "GET") {
                         throw new Error(`API handler for ${event.request.method} "${event.request.url}" did not return a response.`);
                     }
+                    if (!match.isPage)
+                        return;
                 }
                 // render
                 const context = await createPageEvent(event);

package/dist/server/spa/handler.d.ts

@@ -3,5 +3,5 @@ import { FetchEvent, HandlerOptions, PageEvent } from "../types";
  *
  * Read more: https://docs.solidjs.com/solid-start/reference/server/create-handler
  */
-export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions), routerLoad?: (event: FetchEvent) => Promise<void>): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function createHandler(fn: (context: PageEvent) => unknown, options?: HandlerOptions | ((context: PageEvent) => HandlerOptions), routerLoad?: (event: FetchEvent) => Promise<void>): import("vinxi/http").EventHandler<import("vinxi/http").EventHandlerRequest, Promise<any>>;
 export declare function createPageEvent(ctx: FetchEvent): Promise<PageEvent>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/start",
-  "version": "1.1.7",
+  "version": "1.2.1",
   "type": "module",
   "author": "Ryan Carniato",
   "license": "MIT",
@@ -56,18 +56,20 @@
   },
   "devDependencies": {
     "solid-js": "^1.9.5",
-    "vinxi": "^0.5.7"
+    "vinxi": "^0.5.7",
+    "vitest": "3.0.5"
   },
   "dependencies": {
     "@tanstack/server-functions-plugin": "1.121.21",
     "@vinxi/plugin-directives": "^0.5.0",
     "@vinxi/server-components": "^0.5.0",
+    "cookie-es": "^2.0.0",
     "defu": "^6.1.2",
     "error-stack-parser": "^2.1.4",
     "html-to-image": "^1.11.11",
     "radix3": "^1.1.0",
-    "seroval": "^1.0.2",
-    "seroval-plugins": "^1.0.2",
+    "seroval": "^1.4.1",
+    "seroval-plugins": "^1.4.0",
     "shiki": "^1.26.1",
     "source-map-js": "^1.0.2",
     "terracotta": "^1.0.4",
@@ -79,6 +81,8 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "build": "node build && pnpm tsc"
+    "build": "node build && pnpm tsc",
+    "test": "vitest",
+    "test:ci": "vitest run"
   }
 }