@solidjs/start 2.0.0-beta.9 → 2.0.0-rc.10

package/dist/config/index.js

@@ -1,14 +1,16 @@
 import { defu } from "defu";
 import { globSync } from "node:fs";
-import { extname, isAbsolute, join } from "node:path";
+import { basename, extname, isAbsolute, join } from "node:path";
 import solid from "vite-plugin-solid";
 import { serverFunctionsPlugin } from "../directives/index.js";
+import { appRootAlias } from "./app-root-alias.js";
 import { boundaryModules } from "./boundary-modules.js";
 import { DEFAULT_EXTENSIONS, VIRTUAL_MODULES, VITE_ENVIRONMENTS } from "./constants.js";
 import { devServer } from "./dev-server.js";
 import { envPlugin } from "./env.js";
 import { SolidStartClientFileRouter, SolidStartServerFileRouter } from "./fs-router.js";
 import { fsRoutes } from "./fs-routes/index.js";
+import { sanitizeChunkFileName, toPickId } from "./fs-routes/tree-shake.js";
 import lazy from "./lazy.js";
 import { manifest } from "./manifest.js";
 import { parseIdQuery } from "./utils.js";
@@ -61,24 +63,33 @@ export function solidStart(options) {
                     },
                 };
             },
-            async config(_, env) {
+            async config(config, env) {
                 const clientInput = [handlers.client];
+                const clientEntryUrl = env.command === "serve" && config.experimental?.bundledDev
+                    ? `assets/${basename(handlers.client, entryExtension)}.js`
+                    : handlers.client;
                 if (env.command === "build") {
                     const clientRouter = globalThis.ROUTERS.client;
                     for (const route of await clientRouter.getRoutes()) {
                         for (const [key, value] of Object.entries(route)) {
                             if (value && key.startsWith("$") && !key.startsWith("$$")) {
-                                function toRouteId(route) {
-                                    return `${route.src}?${route.pick.map((p) => `pick=${p}`).join("&")}`;
-                                }
-                                clientInput.push(toRouteId(value));
+                                clientInput.push(toPickId(value.src, value.pick));
                             }
                         }
                     }
                 }
                 return {
                     appType: "custom",
-                    build: { assetsDir: "_build/assets" },
+                    build: {
+                        assetsDir: "_build/assets",
+                        rolldownOptions: {
+                            output: {
+                                // Keeps route chunks named after their file rather than after
+                                // the `?pick=...` id that addresses them. See toPickId.
+                                sanitizeFileName: sanitizeChunkFileName,
+                            },
+                        },
+                    },
                     optimizeDeps: {
                         // Suppress TS errors from Vite 7 types when configuring Vite 8's Rolldown
                         ...{
@@ -96,7 +107,7 @@ export function solidStart(options) {
                                 write: true,
                                 manifest: true,
                                 outDir: "dist/client",
-                                rollupOptions: {
+                                rolldownOptions: {
                                     input: clientInput,
                                     treeshake: true,
                                     preserveEntrySignatures: "exports-only",
@@ -110,7 +121,7 @@ export function solidStart(options) {
                                 write: true,
                                 manifest: true,
                                 copyPublicDir: false,
-                                rollupOptions: {
+                                rolldownOptions: {
                                     input: handlers.server,
                                 },
                                 outDir: "dist/server",
@@ -123,7 +134,6 @@ export function solidStart(options) {
                     resolve: {
                         alias: {
                             "@solidjs/start/server/entry": handlers.server,
-                            "~": join(process.cwd(), start.appRoot),
                             ...(!start.ssr
                                 ? {
                                     "@solidjs/start/server": "@solidjs/start/server/spa",
@@ -149,7 +159,9 @@ export function solidStart(options) {
                         // esbuild receives a valid JS string literal for the define value
                         "import.meta.env.START_APP_ENTRY": JSON.stringify(appEntryPath),
                         "import.meta.env.START_CLIENT_ENTRY": JSON.stringify(handlers.client),
+                        "import.meta.env.START_CLIENT_ENTRY_URL": JSON.stringify(clientEntryUrl),
                         "import.meta.env.START_DEV_OVERLAY": JSON.stringify(start.devOverlay),
+                        "import.meta.env.SERVER_BASE_URL": JSON.stringify(config.server?.baseURL ?? ""),
                         "import.meta.env.SEROVAL_MODE": JSON.stringify(start.serialization?.mode || "json"),
                     },
                     builder: {
@@ -170,6 +182,7 @@ export function solidStart(options) {
                 };
             },
         },
+        appRootAlias(root, start.appRoot),
         manifest(start),
         fsRoutes({
             routers: {

package/dist/config/lazy.js

@@ -58,12 +58,17 @@ const lazy = () => {
             if (this.environment.name !== VITE_ENVIRONMENTS.client)
                 return;
             for (const chunk of Object.values(bundle)) {
-                if (chunk.type !== "chunk" || !chunk.isDynamicEntry || chunk.facadeModuleId)
+                if (chunk.type !== "chunk" || chunk.facadeModuleId)
+                    continue;
+                if (!chunk.viteMetadata?.importedCss.size)
+                    continue;
+                const moduleIds = chunk.moduleIds.filter(id => !id.endsWith("css"));
+                if (moduleIds.length <= 1)
                     continue;
                 // Has to follow Vites implementation:
                 // https://github.com/vitejs/vite/blob/4be37a8389c67873880f826b01fe40137e1c29a7/packages/vite/src/node/plugins/manifest.ts#L179
                 const chunkName = `_${basename(chunk.fileName)}`;
-                for (const id of chunk.moduleIds) {
+                for (const id of moduleIds) {
                     sharedChunkNames[id] = chunkName;
                 }
             }

package/dist/config/manifest.d.ts

@@ -1,3 +1,6 @@
 import { type PluginOption } from "vite";
 import { type SolidStartOptions } from "./index.ts";
+type StyleFilterOptions = NonNullable<SolidStartOptions["css"]>["filter"];
+export declare function createStyleFilter(options?: StyleFilterOptions): (id: unknown) => boolean;
 export declare function manifest(start: SolidStartOptions): PluginOption;
+export {};

package/dist/config/manifest.js

@@ -1,12 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
-import { version as viteVersion } from "vite";
+import { createFilter, 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";
+const DEFAULT_STYLE_EXCLUDE = /node_modules/;
+export function createStyleFilter(options) {
+    return createFilter(options?.include || [], options?.exclude || DEFAULT_STYLE_EXCLUDE);
+}
 export function manifest(start) {
     let devServer = undefined;
+    const styleFilter = createStyleFilter(start.css?.filter);
     return {
         name: "solid-start:manifest-plugin",
         enforce: "pre",
@@ -28,6 +33,18 @@ export function manifest(start) {
                     return await this.resolve(start.middleware);
                 return `\0${VIRTUAL_MODULES.middleware}`;
             }
+            if (id === VIRTUAL_MODULES.serovalPlugins) {
+                const plugins = start.serialization?.plugins;
+                if (plugins)
+                    return await this.resolve(plugins);
+                return `\0${VIRTUAL_MODULES.serovalPlugins}`;
+            }
+            if (id === VIRTUAL_MODULES.serverFnErrorHandler) {
+                const onError = start.serverFunctions?.onError;
+                if (onError)
+                    return await this.resolve(onError);
+                return `\0${VIRTUAL_MODULES.serverFnErrorHandler}`;
+            }
         },
         async load(id) {
             if (id === `\0${VIRTUAL_MODULES.clientViteManifest}`) {
@@ -40,7 +57,7 @@ export function manifest(start) {
                     if (!entry)
                         throw new Error("No client entry found");
                     let rawManifest;
-                    const viteMajor = parseInt(viteVersion.split('.')[0], 10);
+                    const viteMajor = parseInt(viteVersion.split(".")[0], 10);
                     const manifestKey = Object.keys(globalThis.START_CLIENT_BUNDLE).find(k => k.endsWith("manifest.json"));
                     if (manifestKey && viteMajor < 8) {
                         const manifestAsset = globalThis.START_CLIENT_BUNDLE[manifestKey];
@@ -53,7 +70,8 @@ export function manifest(start) {
                             if (devServer?.environments?.client?.config?.build?.outDir) {
                                 outDir = devServer.environments.client.config.build.outDir;
                             }
-                            else if (this.environment?.config?.build?.outDir && this.environment?.config?.consumer === "client") {
+                            else if (this.environment?.config?.build?.outDir &&
+                                this.environment?.config?.consumer === "client") {
                                 outDir = this.environment.config.build.outDir;
                             }
                             else if (globalThis.START_CLIENT_OUT_DIR) {
@@ -75,6 +93,10 @@ export function manifest(start) {
             }
             else if (id === `\0${VIRTUAL_MODULES.middleware}`)
                 return "export default {};";
+            else if (id === `\0${VIRTUAL_MODULES.serovalPlugins}`)
+                return "export default [];";
+            else if (id === `\0${VIRTUAL_MODULES.serverFnErrorHandler}`)
+                return "export default undefined;";
             else if (id.startsWith("/@manifest")) {
                 if (this.environment.mode !== "dev")
                     throw new Error("@manifest queries are only allowed in dev");
@@ -91,7 +113,7 @@ export function manifest(start) {
                     // Client env does not have css dependencies in mod.transformResult
                     // Aalways use ssr env instead, to prevent hydration mismatches
                     const env = devServer.environments["ssr"];
-                    const styles = await findStylesInModuleGraph(env, id);
+                    const styles = await findStylesInModuleGraph(env, id, styleFilter);
                     const cssAssets = Object.entries(styles).map(([key, value]) => `{
 						tag: "style",
 						attrs: {

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

@@ -8,10 +8,22 @@ function isInvalidForRemoval(path) {
     // This one is for destructured variables
     let target = path;
     if (isPathValid(path, t.isVariableDeclarator)) {
-        target = path.get('id');
+        target = path.get("id");
     }
     return isPathValid(target, t.isObjectPattern) || isPathValid(target, t.isArrayPattern);
 }
+function countValidImport(node) {
+    if (node.importKind === "type") {
+        return 0;
+    }
+    let count = 0;
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== "ImportSpecifier" || specifier.importKind === "value") {
+            count += 1;
+        }
+    }
+    return count;
+}
 export function removeUnusedVariables(program) {
     // TODO(Alexis):
     // This implementation is simple but slow
@@ -34,7 +46,7 @@ export function removeUnusedVariables(program) {
                             if (binding.references === 0 && !binding.path.removed) {
                                 const parent = binding.path.parentPath;
                                 if (isPathValid(parent, t.isImportDeclaration)) {
-                                    if (parent.node.specifiers.length === 1) {
+                                    if (countValidImport(parent.node) <= 1) {
                                         parent.remove();
                                     }
                                     else {
@@ -42,7 +54,7 @@ export function removeUnusedVariables(program) {
                                     }
                                     dirty = true;
                                 }
-                                else if (!(isInvalidForRemoval(binding.path))) {
+                                else if (!isInvalidForRemoval(binding.path)) {
                                     binding.path.remove();
                                     dirty = true;
                                 }

package/dist/directives/xxhash32.js

@@ -34,7 +34,7 @@ function toUtf8(text) {
  * @param seed - optional seed (32-bit unsigned);
  */
 export default function xxHash32(buffer, seed = 0) {
-    buffer = typeof buffer === 'string' ? toUtf8(buffer) : buffer;
+    buffer = typeof buffer === "string" ? toUtf8(buffer) : buffer;
     const b = buffer;
     /*
       Step 1. Initialize internal accumulators
@@ -144,9 +144,7 @@ export default function xxHash32(buffer, seed = 0) {
         const laneP = laneN0 * PRIME32_3 + ((laneN1 * PRIME32_3) << 16);
         acc = (acc + laneP) & 0xffffffff;
         acc = (acc << 17) | (acc >>> 15);
-        acc =
-            ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) &
-                0xffffffff;
+        acc = ((acc & 0xffff) * PRIME32_4 + (((acc >>> 16) * PRIME32_4) << 16)) & 0xffffffff;
     }
     /*
           ```
@@ -162,9 +160,7 @@ export default function xxHash32(buffer, seed = 0) {
         const lane = b[offset];
         acc += lane * PRIME32_5;
         acc = (acc << 11) | (acc >>> 21);
-        acc =
-            ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) &
-                0xffffffff;
+        acc = ((acc & 0xffff) * PRIME32_1 + (((acc >>> 16) * PRIME32_1) << 16)) & 0xffffffff;
     }
     /*
           Step 6. Final mix (avalanche)
@@ -180,13 +176,9 @@ export default function xxHash32(buffer, seed = 0) {
           ```
       */
     acc ^= acc >>> 15;
-    acc =
-        (((acc & 0xffff) * PRIME32_2) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_2) << 16);
+    acc = (((acc & 0xffff) * PRIME32_2) & 0xffffffff) + (((acc >>> 16) * PRIME32_2) << 16);
     acc ^= acc >>> 13;
-    acc =
-        (((acc & 0xffff) * PRIME32_3) & 0xffffffff) +
-            (((acc >>> 16) * PRIME32_3) << 16);
+    acc = (((acc & 0xffff) * PRIME32_3) & 0xffffffff) + (((acc >>> 16) * PRIME32_3) << 16);
     acc ^= acc >>> 16;
     // turn any negatives back into a positive number;
     return acc < 0 ? acc + 4294967296 : acc;

package/dist/fns/client.js

@@ -1,10 +1,11 @@
+import { pushRequest, pushResponse } from "../shared/dev-toolbar/functions/tracker.js";
 import { 
 // serializeToJSONStream,
 serializeToJSONString, } from "./serialization.js";
-import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody, } from "./shared.js";
+import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 let INSTANCE = 0;
-function createRequest(base, id, instance, options) {
-    return fetch(base, {
+async function createRequest(base, id, instance, options) {
+    const request = new Request(base, {
         method: "POST",
         ...options,
         headers: {
@@ -13,6 +14,14 @@ function createRequest(base, id, instance, options) {
             "X-Server-Instance": instance,
         },
     });
+    if (import.meta.env.DEV) {
+        pushRequest(id, instance, request.clone());
+    }
+    const response = await fetch(request);
+    if (import.meta.env.DEV) {
+        pushResponse(id, instance, response.clone());
+    }
+    return response;
 }
 async function initializeResponse(base, id, instance, options, args) {
     // No args, skip serialization
@@ -63,8 +72,8 @@ async function fetchServerFunction(base, id, options, args) {
         return response;
     }
     const result = await extractBody(instance, true, response.clone());
-    if (response.headers.has("X-Error")) {
-        throw result;
+    if (response.headers.has("X-Error") || response.status >= 500) {
+        throw result ?? new Error(`Server function call failed with status ${response.status}`);
     }
     return result;
 }

package/dist/fns/error-handler.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Handles whatever a server function threw, before it reaches the client. Use
+ * it to type the default export of the module named by the
+ * `serverFunctions.onError` option in `vite.config.ts`.
+ *
+ * The handler may be asynchronous. SolidStart awaits its return value before
+ * sending the error to the client. If the handler throws or rejects, SolidStart
+ * sends the original thrown value instead.
+ *
+ * @param thrown The value the server function threw. This is a `Response` when
+ * the server function threw control flow such as a `redirect()`.
+ * @returns `undefined` (or `null`) to send `thrown` unchanged, a `Response` to
+ * preserve control flow, any other replacement value, or a promise resolving
+ * to any of those values.
+ *
+ * @example
+ * ```ts
+ * // src/server-fn-error.ts
+ * import type { ServerFunctionErrorHandler } from "@solidjs/start/server";
+ * import { captureException } from "./your-monitoring-client";
+ *
+ * const onServerFunctionError: ServerFunctionErrorHandler = thrown => {
+ *   // redirect() throws a Response, so returning it preserves that control flow.
+ *   if (thrown instanceof Response) return thrown;
+ *
+ *   captureException(thrown); // or console.error, or any reporter
+ *   return new Error("Something went wrong");
+ * };
+ *
+ * export default onServerFunctionError;
+ * ```
+ */
+export type ServerFunctionErrorHandler = (thrown: unknown) => unknown;
+export declare function applyServerFunctionErrorHandler(thrown: unknown): Promise<unknown>;

package/dist/fns/error-handler.js

@@ -0,0 +1,10 @@
+import onServerFunctionError from "solid-start:server-fn-error-handler";
+export async function applyServerFunctionErrorHandler(thrown) {
+    try {
+        const replacement = await onServerFunctionError?.(thrown);
+        return replacement ?? thrown;
+    }
+    catch {
+        return thrown;
+    }
+}

package/dist/fns/handler.d.ts

@@ -2,4 +2,4 @@ import { type H3Event } from "h3";
 import "solid-start:server-fn-manifest";
 import type { FetchEvent } from "../server/types.ts";
 export declare function handleServerFunction(h3Event: H3Event): Promise<unknown>;
-export declare function createSingleFlightHeaders(sourceEvent: FetchEvent): Headers;
+export declare function createSingleFlightHeaders(sourceEvent: FetchEvent, result?: unknown): Headers;

package/dist/fns/handler.js

@@ -17,6 +17,7 @@ import { deserializeFromJSONString, serializeToJSONStream, serializeToJSStream,
 import { BODY_FORMAT_KEY, BodyFormat, extractBody, getHeadersAndBody } from "./shared.js";
 import "solid-start:server-fn-manifest";
 import { getServerFunction, hasServerFunction } from "./registration.js";
+import { applyServerFunctionErrorHandler } from "./error-handler.js";
 import { getExpectedRedirectStatus } from "../server/util.js";
 export async function handleServerFunction(h3Event) {
     const event = getFetchEvent(h3Event);
@@ -109,7 +110,7 @@ export async function handleServerFunction(h3Event) {
         }
         // handle no JS success case
         if (!instance)
-            return handleNoJS(result, request, parsed);
+            return await handleNoJS(result, request, parsed);
         const body = getHeadersAndBody(result);
         if (body) {
             return new Response(body.body, {
@@ -121,10 +122,10 @@ export async function handleServerFunction(h3Event) {
             h3Event.res.headers.set("content-type", "text/javascript");
             return serializeToJSStream(instance, result);
         }
-        h3Event.res.headers.set("content-type", "text/plain");
         return serializeToJSONStream(result);
     }
     catch (x) {
+        x = await applyServerFunctionErrorHandler(x);
         if (x instanceof Response) {
             if (singleFlight && instance) {
                 x = await handleSingleFlight(event, x);
@@ -144,10 +145,10 @@ export async function handleServerFunction(h3Event) {
         }
         else if (instance) {
             const error = x instanceof Error ? x.message : typeof x === "string" ? x : "true";
-            h3Event.res.headers.set("X-Error", error.replace(/[\r\n]+/g, ""));
+            h3Event.res.headers.set("X-Error", toHeaderValue(error));
         }
         else {
-            x = handleNoJS(x, request, parsed, true);
+            x = await handleNoJS(x, request, parsed, true);
         }
         if (instance) {
             const body = getHeadersAndBody(x);
@@ -158,7 +159,7 @@ export async function handleServerFunction(h3Event) {
                     headers.set("X-Error", errorHeader);
                 }
                 return new Response(body.body, {
-                    headers: body.headers,
+                    headers,
                 });
             }
             h3Event.res.headers.set(BODY_FORMAT_KEY, BodyFormat.Seroval);
@@ -166,13 +167,36 @@ export async function handleServerFunction(h3Event) {
                 h3Event.res.headers.set("content-type", "text/javascript");
                 return serializeToJSStream(instance, x);
             }
-            h3Event.res.headers.set("content-type", "text/plain");
             return serializeToJSONStream(x);
         }
         return x;
     }
 }
-function handleNoJS(result, request, parsed, thrown) {
+// header values must be ByteString-safe (no chars > 0xFF), otherwise Headers.set throws
+function toHeaderValue(value) {
+    const stripped = value.replace(/[\r\n]+/g, "");
+    try {
+        return /[^\x00-\xFF]/.test(stripped) ? encodeURIComponent(stripped) : stripped;
+    }
+    catch {
+        // encodeURIComponent throws on lone surrogates
+        return "true";
+    }
+}
+function getRefererLocation(request, url) {
+    const referer = request.headers.get("referer");
+    try {
+        if (referer)
+            return new URL(referer).toString();
+    }
+    catch {
+        // fall through to the app root below
+    }
+    // no usable referer (e.g. a no-referrer policy): the app root still beats
+    // leaving the browser sitting on the server function endpoint
+    return new URL(import.meta.env.BASE_URL, url.origin).toString();
+}
+async function handleNoJS(result, request, parsed, thrown) {
     const url = new URL(request.url);
     const isError = result instanceof Error;
     let statusCode = 302;
@@ -183,10 +207,19 @@ function handleNoJS(result, request, parsed, thrown) {
             headers.set(`Location`, new URL(result.headers.get("Location"), url.origin + import.meta.env.BASE_URL).toString());
             statusCode = getExpectedRedirectStatus(result);
         }
+        else {
+            // responses that carry a value rather than a destination (json(), reload())
+            // still have to send the browser back to the page the form came from
+            headers.set("Location", getRefererLocation(request, url));
+        }
+        // the body is dropped from the redirect, so don't advertise its type
+        headers.delete("Content-Type");
+        // mirror the JS path: the flash cookie carries the value, not the Response
+        result = result.customBody ? await result.customBody() : null;
     }
     else
         headers = new Headers({
-            Location: new URL(request.headers.get("referer")).toString(),
+            Location: getRefererLocation(request, url),
         });
     if (result) {
         headers.append("Set-Cookie", `flash=${encodeURIComponent(JSON.stringify({
@@ -194,7 +227,9 @@ function handleNoJS(result, request, parsed, thrown) {
             result: isError ? result.message : result,
             thrown: thrown,
             error: isError,
-            input: [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]],
+            input: parsed.length
+                ? [...parsed.slice(0, -1), [...parsed[parsed.length - 1].entries()]]
+                : [],
         }))}; Secure; HttpOnly;`);
     }
     return new Response(null, {
@@ -203,13 +238,19 @@ function handleNoJS(result, request, parsed, thrown) {
     });
 }
 let App;
-export function createSingleFlightHeaders(sourceEvent) {
+export function createSingleFlightHeaders(sourceEvent, result) {
     // cookie handling logic is pretty simplistic so this might be imperfect
     // unclear if h3 internals are available on all platforms but we need a way to
     // update request headers on the underlying H3 event.
     const headers = new Headers(sourceEvent.request.headers);
     const cookies = parseCookies(sourceEvent.nativeEvent);
     const SetCookies = sourceEvent.response.headers.getSetCookie();
+    // cookies attached to the returned/thrown response (eg. `redirect(to, { headers })`)
+    // haven't been merged onto the event response yet, but a browser round trip would
+    // have sent them back with the next request, so apply them here too. They come after
+    // the ones on the event response, so they win on conflict.
+    if (result instanceof Response)
+        SetCookies.push(...result.headers.getSetCookie());
     headers.delete("cookie");
     // let useH3Internals = false;
     // if (sourceEvent.nativeEvent.node?.req) {
@@ -219,7 +260,12 @@ export function createSingleFlightHeaders(sourceEvent) {
     SetCookies.forEach(cookie => {
         if (!cookie)
             return;
-        const { maxAge, expires, name, value } = parseSetCookie(cookie);
+        // `parseSetCookie` returns undefined for forbidden cookie names and for
+        // cookies with an empty name and value.
+        const parsed = parseSetCookie(cookie);
+        if (!parsed)
+            return;
+        const { maxAge, expires, name, value } = parsed;
         if (maxAge != null && maxAge <= 0) {
             delete cookies[name];
             return;
@@ -248,7 +294,7 @@ async function handleSingleFlight(sourceEvent, result) {
     }
     const event = { ...sourceEvent };
     event.request = new Request(url, {
-        headers: createSingleFlightHeaders(sourceEvent),
+        headers: createSingleFlightHeaders(sourceEvent, result),
     });
     return await provideRequestEvent(event, async () => {
         await createPageEvent(event);

package/dist/fns/plugins.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Re-exports Seroval's plugin authoring API for use with the
+ * `serialization.plugins` option in `vite.config.ts`.
+ *
+ * Importing from here rather than depending on `seroval` directly keeps plugin
+ * authors on the exact Seroval version SolidStart serializes with. A mismatched
+ * version would not fail the build: it would produce plugin nodes the other end
+ * of the wire can't interpret.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ *
+ * @example
+ * ```ts
+ * // src/seroval-plugins.ts
+ * import { createPlugin } from "@solidjs/start/serialization";
+ * import { ObjectId } from "mongodb";
+ *
+ * const ObjectIdPlugin = createPlugin<ObjectId, { hex: any }>({
+ *   tag: "app/ObjectId",
+ *   test: value => value instanceof ObjectId,
+ *   parse: {
+ *     sync: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *     async: async (value, ctx) => ({ hex: await ctx.parse(value.toHexString()) }),
+ *     stream: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *   },
+ *   serialize: (node, ctx) => `globalThis.ObjectId(${ctx.serialize(node.hex)})`,
+ *   deserialize: (node, ctx) => new ObjectId(ctx.deserialize(node.hex) as string),
+ * });
+ *
+ * export default [ObjectIdPlugin];
+ * ```
+ */
+export { createPlugin, OpaqueReference } from "seroval";
+export type { AsyncParsePluginContext, DeserializePluginContext, Plugin, PluginData, PluginInfo, SerializePluginContext, SerovalNode, StreamParsePluginContext, SyncParsePluginContext, } from "seroval";

package/dist/fns/plugins.js

@@ -0,0 +1,33 @@
+/**
+ * Re-exports Seroval's plugin authoring API for use with the
+ * `serialization.plugins` option in `vite.config.ts`.
+ *
+ * Importing from here rather than depending on `seroval` directly keeps plugin
+ * authors on the exact Seroval version SolidStart serializes with. A mismatched
+ * version would not fail the build: it would produce plugin nodes the other end
+ * of the wire can't interpret.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ *
+ * @example
+ * ```ts
+ * // src/seroval-plugins.ts
+ * import { createPlugin } from "@solidjs/start/serialization";
+ * import { ObjectId } from "mongodb";
+ *
+ * const ObjectIdPlugin = createPlugin<ObjectId, { hex: any }>({
+ *   tag: "app/ObjectId",
+ *   test: value => value instanceof ObjectId,
+ *   parse: {
+ *     sync: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *     async: async (value, ctx) => ({ hex: await ctx.parse(value.toHexString()) }),
+ *     stream: (value, ctx) => ({ hex: ctx.parse(value.toHexString()) }),
+ *   },
+ *   serialize: (node, ctx) => `globalThis.ObjectId(${ctx.serialize(node.hex)})`,
+ *   deserialize: (node, ctx) => new ObjectId(ctx.deserialize(node.hex) as string),
+ * });
+ *
+ * export default [ObjectIdPlugin];
+ * ```
+ */
+export { createPlugin, OpaqueReference } from "seroval";

package/dist/fns/serialization.d.ts

@@ -1,5 +1,20 @@
 export declare function serializeToJSStream(id: string, value: any): ReadableStream<any>;
 export declare function serializeToJSONStream(value: any): ReadableStream<any>;
+export declare class SerovalChunkReader {
+    reader: ReadableStreamDefaultReader<Uint8Array>;
+    buffer: Uint8Array;
+    done: boolean;
+    constructor(stream: ReadableStream<Uint8Array>);
+    readChunk(): Promise<void>;
+    next(): Promise<{
+        done: true;
+        value: undefined;
+    } | {
+        done: false;
+        value: string;
+    }>;
+    drain(interpret: (chunk: string) => void): Promise<void>;
+}
 export declare function serializeToJSONString(value: any): Promise<string>;
 export declare function deserializeFromJSONString(json: string): Promise<unknown>;
 export declare function deserializeJSONStream(response: Response | Request): Promise<unknown>;