@@ -0,0 +1,25 @@
+---
+"@solidjs/start": minor
+---
+
+Add `serialization.plugins` to configure custom Seroval plugins for server functions.
+
+Values Seroval has no built-in support for (Mongo's `ObjectId`, Prisma's `Decimal`, `Temporal`, and other custom classes) previously threw when returned from or passed to a server function. Point the new option at a module whose default export is an array of plugins:
+
+```ts
+// vite.config.ts
+solidStart({
+  serialization: {
+    plugins: "src/seroval-plugins.ts",
+  },
+});
+```
+
+```ts
+// src/seroval-plugins.ts
+import { createPlugin } from "@solidjs/start/serialization";
+```
+
+The module is bundled into both the client and the server so both ends of a server function agree on the format, so it must not import server-only code. SolidStart's built-in plugins keep precedence. Only server-function and action payloads are affected; the SSR hydration payload is serialized by `solid-js/web`.
+
+Also adds a `@solidjs/start/serialization` entrypoint re-exporting Seroval's `createPlugin`, `OpaqueReference`, and plugin types, so plugin authors stay on the same Seroval version SolidStart serializes with.
@@ -0,0 +1,5 @@
+---
+"@solidjs/start": patch
+---
+
+Scope the built-in `~` alias to the app package, so files in other workspace packages can map `~` to their own root through an importer-aware plugin such as `vite-tsconfig-paths`. In stylesheets and asset URLs (CSS `@import`, `url()`, `new URL(..., import.meta.url)`) `~` still always means the app root, since Vite resolves those without running plugins.
@@ -73,6 +73,19 @@ test.describe("server-function", () => {
     await expect(page.locator("#server-fn-test")).toContainText('{"result":true}');
   });
 
+  /**
+   * A custom Seroval plugin registered through `serialization.plugins` must
+   * apply to both the request and the response payload, so a class Seroval has
+   * no built-in support for survives the round trip with its prototype intact.
+   * https://github.com/solidjs/solid-start/issues/1474
+   */
+  test("should round-trip a custom class through a custom seroval plugin", async ({ page }) => {
+    await page.goto("http://localhost:3000/server-function-custom-class");
+    await expect(page.locator("#server-fn-test")).toContainText(
+      '{"receivedInstance":true,"receivedHex":"507f191e810c19729de860ea","returnedInstance":true,"returnedHex":"507f1f77bcf86cd799439011"}',
+    );
+  });
+
   test("should build with a server function w/ form data", async ({ page }) => {
     await page.goto("http://localhost:3000/server-function-form-data");
     await expect(page.locator("#server-fn-test")).toContainText('{"result":true}');
 
@@ -0,0 +1,39 @@
+import { createEffect, createSignal } from "solid-js";
+import { ObjectId } from "../utils/object-id.ts";
+
+/**
+ * Exercises `serialization.plugins`: a class Seroval has no built-in support
+ * for has to survive both directions of a server function call.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ */
+async function echoObjectId(id: ObjectId) {
+  "use server";
+
+  return {
+    receivedInstance: id instanceof ObjectId,
+    receivedHex: id.toHexString(),
+    returned: new ObjectId("507f1f77bcf86cd799439011"),
+  };
+}
+
+export default function App() {
+  const [output, setOutput] = createSignal<Record<string, unknown>>({});
+
+  createEffect(async () => {
+    const result = await echoObjectId(new ObjectId("507f191e810c19729de860ea"));
+
+    setOutput({
+      receivedInstance: result.receivedInstance,
+      receivedHex: result.receivedHex,
+      returnedInstance: result.returned instanceof ObjectId,
+      returnedHex: result.returned.toHexString(),
+    });
+  });
+
+  return (
+    <main>
+      <span id="server-fn-test">{JSON.stringify(output())}</span>
+    </main>
+  );
+}
@@ -0,0 +1,27 @@
+import { createPlugin } from "@solidjs/start/serialization";
+import { ObjectId } from "./utils/object-id.ts";
+
+/**
+ * Bundled into both the client and the server via `serialization.plugins`, so
+ * this module must not import server-only code.
+ *
+ * `deserialize` is what rebuilds the value under the default `"json"`
+ * serialization mode. `serialize` is only used by `mode: "js"`, where the
+ * payload is evaluated on the client and can therefore reference globals only,
+ * which is why it reaches for `globalThis` rather than the imported class.
+ */
+const ObjectIdPlugin = createPlugin<ObjectId, { hex: any }>({
+  tag: "tests/ObjectId",
+  test: value => value instanceof ObjectId,
+  parse: {
+    sync: (value, ctx) => ({ hex: ctx.parse(value.hex) }),
+    async: async (value, ctx) => ({ hex: await ctx.parse(value.hex) }),
+    stream: (value, ctx) => ({ hex: ctx.parse(value.hex) }),
+  },
+  serialize: (node, ctx) => `globalThis.ObjectId(${ctx.serialize(node.hex)})`,
+  deserialize: (node, ctx) => new ObjectId(ctx.deserialize(node.hex) as string),
+});
+
+(globalThis as any).ObjectId = (hex: string) => new ObjectId(hex);
+
+export default [ObjectIdPlugin];
@@ -0,0 +1,14 @@
+/**
+ * Stands in for a custom class that Seroval has no built-in support for, such
+ * as Mongo's `ObjectId` or Prisma's `Decimal`. Serializing one of these across
+ * a server function boundary requires a custom Seroval plugin.
+ *
+ * @see https://github.com/solidjs/solid-start/issues/1474
+ */
+export class ObjectId {
+  constructor(readonly hex: string) {}
+
+  toHexString() {
+    return this.hex;
+  }
+}
@@ -8,6 +8,9 @@ export default defineConfig({
   },
   plugins: [
     solidStart({
+      serialization: {
+        plugins: "src/seroval-plugins.ts",
+      },
       env: {
         server: {
           load() {
 
@@ -24,7 +24,8 @@
     "./http": "./src/http/index.ts",
     "./env": "./env.d.ts",
     "./fns/server": "./src/fns/server.ts",
-    "./fns/client": "./src/fns/client.ts"
+    "./fns/client": "./src/fns/client.ts",
+    "./serialization": "./src/fns/plugins.ts"
   },
   "publishConfig": {
     "exports": {
@@ -39,7 +40,8 @@
       "./http": "./dist/http/index.js",
       "./env": "./env.d.ts",
       "./fns/server": "./dist/fns/server.js",
-      "./fns/client": "./dist/fns/client.js"
+      "./fns/client": "./dist/fns/client.js",
+      "./serialization": "./dist/fns/plugins.js"
     },
     "access": "public"
   },
 
@@ -0,0 +1,77 @@
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { build, createServer, type Plugin, type ViteDevServer } from "vite";
+import { afterEach, expect, it } from "vitest";
+
+import { appRootAlias } from "./app-root-alias.ts";
+
+const roots: string[] = [];
+const servers: ViteDevServer[] = [];
+
+/** An app package with a `src` app root, plus a nested `lib` workspace package. */
+function createProject() {
+  const root = realpathSync.native(mkdtempSync(join(tmpdir(), "solid-start-app-root-alias-")));
+  roots.push(root);
+
+  mkdirSync(join(root, "src"));
+  mkdirSync(join(root, "lib/src"), { recursive: true });
+  writeFileSync(join(root, "package.json"), "{}");
+  writeFileSync(join(root, "lib/package.json"), "{}");
+  writeFileSync(join(root, "src/demo.ts"), 'export default "app";');
+  writeFileSync(join(root, "lib/src/demo.ts"), 'export default "package";');
+
+  return root;
+}
+
+afterEach(async () => {
+  await Promise.all(servers.splice(0).map(server => server.close()));
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true });
+});
+
+it("resolves ~ for the app package, leaving other packages to importer-aware plugins", async () => {
+  const root = createProject();
+  const packageRoot = join(root, "lib");
+  // Stands in for vite-tsconfig-paths: maps `~` to the importing package's root.
+  const packagePaths: Plugin = {
+    name: "test:package-paths",
+    enforce: "pre",
+    resolveId(id, importer, options) {
+      if (id !== "~/demo" || !importer?.startsWith(packageRoot)) return null;
+      return this.resolve(join(packageRoot, "src/demo"), importer, { ...options, skipSelf: true });
+    },
+  };
+  const server = await createServer({
+    configFile: false,
+    logLevel: "silent",
+    root,
+    server: { middlewareMode: true },
+    plugins: [appRootAlias(root, "./src"), packagePaths],
+  });
+  servers.push(server);
+
+  await expect(
+    server.pluginContainer.resolveId("~/demo", join(root, "src/app.tsx")),
+  ).resolves.toMatchObject({ id: join(root, "src/demo.ts") });
+  await expect(
+    server.pluginContainer.resolveId("~/demo", join(root, "lib/src/index.ts")),
+  ).resolves.toMatchObject({ id: join(root, "lib/src/demo.ts") });
+});
+
+it("resolves ~ in stylesheets, which are resolved without user plugins", async () => {
+  const root = createProject();
+  writeFileSync(join(root, "src/theme.css"), "body { color: red; }");
+  writeFileSync(join(root, "src/app.css"), '@import "~/theme.css";');
+  writeFileSync(join(root, "src/main.js"), 'import "./app.css";');
+
+  const result = (await build({
+    configFile: false,
+    logLevel: "silent",
+    root,
+    plugins: [appRootAlias(root, "./src")],
+    build: { write: false, rollupOptions: { input: join(root, "src/main.js") } },
+  })) as { output: { fileName: string; source?: unknown }[] };
+
+  const css = result.output.find(chunk => chunk.fileName.endsWith(".css"));
+  expect(String(css?.source)).toContain("color:red");
+});
@@ -0,0 +1,65 @@
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { normalizePath, type Plugin } from "vite";
+
+/**
+ * `~/app.css`, `~/logo.svg`, ... but not `~/lib/api.ts` or `~/components/Counter`.
+ *
+ * CSS `@import`, `url()`, preprocessor imports and `new URL(..., import.meta.url)`
+ * are resolved by internal Vite resolvers that only run the alias plugin, never
+ * user plugins, so those ids can never reach `resolveId` below. Keeping non-module
+ * ids on a plain alias preserves `~` in stylesheets and asset URLs, where it always
+ * means the app root.
+ */
+const NON_MODULE_ID = /^~\/([^?#]*\.(?![cm]?[jt]sx?(?:[?#]|$))[^./?#]+(?:[?#].*)?)$/;
+
+/**
+ * Provides SolidStart's `~` app-root alias without claiming module imports made
+ * by other workspace packages. Those packages may map `~` to their own root
+ * through an importer-aware resolver such as vite-tsconfig-paths.
+ */
+export function appRootAlias(projectRoot: string, appRoot: string): Plugin {
+  const appDir = normalizePath(resolve(projectRoot, appRoot));
+  const packageRoots = new Map<string, string | undefined>();
+
+  /** Nearest directory at or above `directory` that holds a `package.json`. */
+  function packageRoot(directory: string): string | undefined {
+    if (!packageRoots.has(directory)) {
+      const parent = dirname(directory);
+      packageRoots.set(
+        directory,
+        existsSync(join(directory, "package.json"))
+          ? directory
+          : parent === directory
+            ? undefined
+            : packageRoot(parent),
+      );
+    }
+    return packageRoots.get(directory);
+  }
+
+  const appPackage = packageRoot(appDir);
+
+  /** True only when the importer demonstrably belongs to another package. */
+  function isForeignImporter(importer: string) {
+    const file = normalizePath(importer.replace(/[?#].*$/s, ""));
+    if (!isAbsolute(file)) return false;
+    const owner = packageRoot(dirname(file));
+    return owner !== undefined && owner !== appPackage;
+  }
+
+  return {
+    name: "solid-start:app-root-alias",
+    enforce: "pre",
+    config() {
+      return { resolve: { alias: [{ find: NON_MODULE_ID, replacement: `${appDir}/$1` }] } };
+    },
+    async resolveId(id, importer, options) {
+      if (id !== "~" && !id.startsWith("~/")) return null;
+      if (importer && isForeignImporter(importer)) return null;
+
+      const target = join(appDir, id.slice(1));
+      return (await this.resolve(target, importer, { ...options, skipSelf: true })) ?? target;
+    },
+  };
+}
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@solidjs/start": patch
 +---
++
 +Scope the built-in `~` alias to the app package, so files in other workspace packages can map `~` to their own root through an importer-aware plugin such as `vite-tsconfig-paths`. In stylesheets and asset URLs (CSS `@import`, `url()`, `new URL(..., import.meta.url)`) `~` still always means the app root, since Vite resolves those without running plugins.