@tanstack/start-plugin-core 1.167.18 → 1.167.19

package/dist/esm/vite/start-router-plugin/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":[],"sources":["../../../../src/vite/start-router-plugin/plugin.ts"],"sourcesContent":["import {\n  tanStackRouterCodeSplitter,\n  tanstackRouterAutoImport,\n  tanstackRouterGenerator,\n} from '@tanstack/router-plugin/vite'\nimport path from 'pathe'\nimport { normalizePath } from 'vite'\nimport { VITE_ENVIRONMENT_NAMES } from '../../constants'\nimport { routesManifestPlugin } from '../../start-router-plugin/generator-plugins/routes-manifest-plugin'\nimport { prerenderRoutesPlugin } from '../../start-router-plugin/generator-plugins/prerender-routes-plugin'\nimport { buildRouteTreeFileFooterFromConfig } from '../../start-router-plugin/route-tree-footer'\nimport { pruneServerOnlySubtrees } from '../../start-router-plugin/pruneServerOnlySubtrees'\nimport { SERVER_PROP } from '../../start-router-plugin/constants'\nimport type { GetConfigFn } from '../../types'\nimport type { TanStackStartVitePluginCoreOptions } from '../types'\nimport type {\n  Generator,\n  GeneratorPlugin,\n  RouteNode,\n} from '@tanstack/router-generator'\nimport type { DevEnvironment, Plugin, PluginOption } from 'vite'\nimport type { TanStackStartInputConfig } from '../../schema'\n\nfunction isServerOnlyNode(node: RouteNode | undefined) {\n  if (!node?.createFileRouteProps) {\n    return false\n  }\n  return (\n    node.createFileRouteProps.has(SERVER_PROP) &&\n    node.createFileRouteProps.size === 1\n  )\n}\n\nexport function tanStackStartRouter(\n  startPluginOpts: TanStackStartInputConfig,\n  getConfig: GetConfigFn,\n  corePluginOpts: TanStackStartVitePluginCoreOptions,\n): Array<PluginOption> {\n  const getGeneratedRouteTreePath = () => {\n    const { startConfig } = getConfig()\n    return path.resolve(startConfig.router.generatedRouteTree)\n  }\n\n  let clientEnvironment: DevEnvironment | null = null\n  function invalidate() {\n    if (!clientEnvironment) {\n      return\n    }\n\n    const mod = clientEnvironment.moduleGraph.getModuleById(\n      getGeneratedRouteTreePath(),\n    )\n    if (mod) {\n      clientEnvironment.moduleGraph.invalidateModule(mod)\n    }\n    clientEnvironment.hot.send({ type: 'full-reload', path: '*' })\n  }\n\n  let generatorInstance: Generator | null = null\n\n  const clientTreeGeneratorPlugin: GeneratorPlugin = {\n    name: 'start-client-tree-plugin',\n    init({ generator }) {\n      generatorInstance = generator\n    },\n    afterTransform({ node, prevNode }) {\n      if (isServerOnlyNode(node) !== isServerOnlyNode(prevNode)) {\n        invalidate()\n      }\n    },\n  }\n\n  let routeTreeFileFooter: Array<string> | null = null\n\n  function getRouteTreeFileFooter() {\n    if (routeTreeFileFooter) {\n      return routeTreeFileFooter\n    }\n    routeTreeFileFooter = [\n      ...buildRouteTreeFileFooterFromConfig({\n        generatedRouteTreePath: getGeneratedRouteTreePath(),\n        getConfig,\n        corePluginOpts,\n      }),\n    ]\n    return routeTreeFileFooter\n  }\n\n  let resolvedGeneratedRouteTreePath: string | null = null\n  const clientTreePlugin: Plugin = {\n    name: 'tanstack-start:route-tree-client-plugin',\n    enforce: 'pre',\n    applyToEnvironment: (env) => env.name === VITE_ENVIRONMENT_NAMES.client,\n    configureServer(server) {\n      clientEnvironment = server.environments[VITE_ENVIRONMENT_NAMES.client]\n    },\n    config() {\n      type LoadObjectHook = Extract<\n        typeof clientTreePlugin.load,\n        { filter?: unknown }\n      >\n      resolvedGeneratedRouteTreePath = normalizePath(\n        getGeneratedRouteTreePath(),\n      )\n      ;(clientTreePlugin.load as LoadObjectHook).filter = {\n        id: { include: new RegExp(resolvedGeneratedRouteTreePath) },\n      }\n    },\n\n    load: {\n      filter: {\n        // this will be set in the config hook above since it relies on `config` hook being called first\n      },\n      async handler() {\n        if (!generatorInstance) {\n          throw new Error('Generator instance not initialized')\n        }\n        const crawlingResult = await generatorInstance.getCrawlingResult()\n        if (!crawlingResult) {\n          throw new Error('Crawling result not available')\n        }\n        const prunedAcc = pruneServerOnlySubtrees(crawlingResult)\n        const acc = {\n          ...crawlingResult.acc,\n          ...prunedAcc,\n        }\n        const buildResult = generatorInstance.buildRouteTree({\n          ...crawlingResult,\n          acc,\n          config: {\n            // importRoutesUsingAbsolutePaths: true,\n            // addExtensions: true,\n            disableTypes: true,\n            enableRouteTreeFormatting: false,\n            routeTreeFileHeader: [],\n            routeTreeFileFooter: [],\n          },\n        })\n        return { code: buildResult.routeTreeContent, map: null }\n      },\n    },\n  }\n  return [\n    clientTreePlugin,\n    tanstackRouterGenerator(() => {\n      const routerConfig = getConfig().startConfig.router\n      const plugins = [clientTreeGeneratorPlugin, routesManifestPlugin()]\n      if (startPluginOpts.prerender?.enabled === true) {\n        plugins.push(prerenderRoutesPlugin())\n      }\n      return {\n        ...routerConfig,\n        target: corePluginOpts.framework,\n        routeTreeFileFooter: getRouteTreeFileFooter,\n        plugins,\n      }\n    }),\n    tanStackRouterCodeSplitter(() => {\n      const routerConfig = getConfig().startConfig.router\n      return {\n        ...routerConfig,\n        codeSplittingOptions: {\n          ...routerConfig.codeSplittingOptions,\n          deleteNodes: ['ssr', 'server', 'headers'],\n          addHmr: true,\n        },\n        plugin: {\n          vite: { environmentName: VITE_ENVIRONMENT_NAMES.client },\n        },\n      }\n    }),\n    tanStackRouterCodeSplitter(() => {\n      const routerConfig = getConfig().startConfig.router\n      return {\n        ...routerConfig,\n        codeSplittingOptions: {\n          ...routerConfig.codeSplittingOptions,\n          addHmr: false,\n        },\n        plugin: {\n          vite: { environmentName: VITE_ENVIRONMENT_NAMES.server },\n        },\n      }\n    }),\n    tanstackRouterAutoImport(startPluginOpts.router),\n  ]\n}\n"],"mappings":"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"}

package/dist/esm/vite/types.d.ts

@@ -0,0 +1,15 @@
+import { TanStackStartCoreOptions } from '../types.js';
+export interface ViteRscForwardSsrResolverStrategy {
+    type: 'vite-rsc-forward';
+    sourceEnvironmentName: string;
+    sourceEntry: string;
+    exportName: 'getServerFnById';
+}
+export type SsrResolverStrategy = {
+    type: 'default';
+} | ViteRscForwardSsrResolverStrategy;
+export type TanStackStartVitePluginCoreOptions = TanStackStartCoreOptions & {
+    providerEnvironmentName: string;
+    ssrIsProvider: boolean;
+    ssrResolverStrategy: SsrResolverStrategy;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-plugin-core",
-  "version": "1.167.18",
+  "version": "1.167.19",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -34,6 +34,17 @@
         "default": "./dist/esm/index.js"
       }
     },
+    "./utils": {
+      "import": {
+        "types": "./dist/esm/utils.d.ts",
+        "default": "./dist/esm/utils.js"
+      }
+    },
+    "./vite/types": {
+      "import": {
+        "types": "./dist/esm/vite/types.d.ts"
+      }
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,

package/src/config-context.ts

@@ -0,0 +1,138 @@
+import {
+  createNormalizedBasePaths,
+  createNormalizedOutputDirectories,
+  deriveRouterBasepath,
+  resolveStartEntryPlan,
+} from './planning'
+import type { TanStackStartOutputConfig } from './schema'
+import type {
+  GetConfigFn,
+  ResolvedStartConfig,
+  TanStackStartCoreOptions,
+} from './types'
+
+export interface StartConfigContext {
+  resolvedStartConfig: ResolvedStartConfig
+  getConfig: GetConfigFn
+  resolveEntries: () => ReturnType<typeof resolveStartEntryPlan>
+}
+
+export function createStartConfigContext<TInputConfig>(opts: {
+  corePluginOpts: TanStackStartCoreOptions
+  startPluginOpts: TInputConfig | undefined
+  parseConfig: (
+    opts: TInputConfig | undefined,
+    core: { framework: TanStackStartCoreOptions['framework'] },
+    root: string,
+  ) => TanStackStartOutputConfig
+}): StartConfigContext {
+  const resolvedStartConfig: ResolvedStartConfig = {
+    root: '',
+    startFilePath: undefined,
+    routerFilePath: '',
+    srcDirectory: '',
+    basePaths: {
+      publicBase: '',
+      assetBase: {
+        dev: '',
+        build: '',
+      },
+    },
+    outputDirectories: {
+      client: '',
+      server: '',
+    },
+  }
+
+  let startConfig: TanStackStartOutputConfig | null = null
+  let resolvedEntryPlanCache:
+    | ReturnType<typeof resolveStartEntryPlan>
+    | undefined
+
+  function requireRoot(): string {
+    if (!resolvedStartConfig.root) {
+      throw new Error(`Cannot get config before root is resolved`)
+    }
+
+    return resolvedStartConfig.root
+  }
+
+  function getStartConfig(): TanStackStartOutputConfig {
+    if (!startConfig) {
+      startConfig = opts.parseConfig(
+        opts.startPluginOpts,
+        { framework: opts.corePluginOpts.framework },
+        requireRoot(),
+      )
+    }
+
+    return startConfig
+  }
+
+  function getResolvedEntryPlan() {
+    if (resolvedEntryPlanCache) {
+      return resolvedEntryPlanCache
+    }
+
+    resolvedEntryPlanCache = resolveStartEntryPlan({
+      root: requireRoot(),
+      startConfig: getStartConfig(),
+      defaultEntryPaths: opts.corePluginOpts.defaultEntryPaths,
+    })
+
+    Object.assign(resolvedStartConfig, {
+      srcDirectory: resolvedEntryPlanCache.srcDirectory,
+      startFilePath: resolvedEntryPlanCache.startFilePath,
+      routerFilePath: resolvedEntryPlanCache.routerFilePath,
+    })
+
+    return resolvedEntryPlanCache
+  }
+
+  const getConfig: GetConfigFn = () => {
+    const startConfig = getStartConfig()
+    getResolvedEntryPlan()
+
+    return { startConfig, resolvedStartConfig }
+  }
+
+  function resolveEntries() {
+    return getResolvedEntryPlan()
+  }
+
+  return {
+    resolvedStartConfig,
+    getConfig,
+    resolveEntries,
+  }
+}
+
+export function applyResolvedBaseAndOutput(opts: {
+  resolvedStartConfig: ResolvedStartConfig
+  root: string
+  publicBase: string
+  clientOutputDirectory: string
+  serverOutputDirectory: string
+}): void {
+  opts.resolvedStartConfig.root = opts.root
+  opts.resolvedStartConfig.basePaths = createNormalizedBasePaths({
+    publicBase: opts.publicBase,
+  })
+  opts.resolvedStartConfig.outputDirectories =
+    createNormalizedOutputDirectories({
+      client: opts.clientOutputDirectory,
+      server: opts.serverOutputDirectory,
+    })
+}
+
+export function applyResolvedRouterBasepath(opts: {
+  resolvedStartConfig: ResolvedStartConfig
+  startConfig: TanStackStartOutputConfig
+}): string {
+  const routerBasepath = deriveRouterBasepath({
+    configuredBasepath: opts.startConfig.router.basepath,
+    publicBase: opts.resolvedStartConfig.basePaths.publicBase,
+  })
+  opts.startConfig.router.basepath = routerBasepath
+  return routerBasepath
+}

package/src/constants.ts

@@ -1,12 +1,16 @@
-export const VITE_ENVIRONMENT_NAMES = {
+export const START_ENVIRONMENT_NAMES = {
   // 'ssr' is chosen as the name for the server environment to ensure backwards compatibility
   // with vite plugins that are not compatible with the new vite environment API (e.g. tailwindcss)
   server: 'ssr',
   client: 'client',
 } as const
 
-export type ViteEnvironmentNames =
-  (typeof VITE_ENVIRONMENT_NAMES)[keyof typeof VITE_ENVIRONMENT_NAMES]
+export type StartEnvironmentName =
+  (typeof START_ENVIRONMENT_NAMES)[keyof typeof START_ENVIRONMENT_NAMES]
+
+export const VITE_ENVIRONMENT_NAMES = START_ENVIRONMENT_NAMES
+
+export type ViteEnvironmentNames = StartEnvironmentName
 
 // for client and router:
 // if a user has a custom server/client entry point file, resolve.alias will point to this

package/src/index.ts

@@ -1,6 +1,6 @@
 export type { TanStackStartInputConfig } from './schema'
-
-export { TanStackStartVitePluginCore } from './plugin'
-export { resolveViteId } from './utils'
-
-export { VITE_ENVIRONMENT_NAMES } from './constants'
+export type { TanStackStartCoreOptions } from './types'
+export type { TanStackStartVitePluginCoreOptions } from './vite/types'
+export type { TanStackStartViteInputConfig } from './vite/schema'
+export { START_ENVIRONMENT_NAMES, VITE_ENVIRONMENT_NAMES } from './constants'
+export { tanStackStartVite } from './vite/plugin'

package/src/planning.ts

@@ -0,0 +1,151 @@
+import { joinPaths } from '@tanstack/router-core'
+import { join } from 'pathe'
+import { resolveEntry } from './resolve-entries'
+import type { TanStackStartOutputConfig } from './schema'
+import type {
+  NormalizedBasePaths,
+  NormalizedOutputDirectories,
+  TanStackStartCoreOptions,
+} from './types'
+
+export interface ResolvedStartEntryPlan {
+  srcDirectory: string
+  startFilePath: string | undefined
+  routerFilePath: string
+  entryPaths: {
+    client: string
+    server: string
+    start: string
+    router: string
+  }
+}
+
+export function normalizePublicBase(base: string | undefined): string {
+  const resolvedBase = base ?? '/'
+
+  if (isFullUrl(resolvedBase)) {
+    return resolvedBase
+  }
+
+  return joinPaths(['/', resolvedBase, '/'])
+}
+
+export function deriveRouterBasepath(opts: {
+  configuredBasepath: string | undefined
+  publicBase: string
+}): string {
+  if (opts.configuredBasepath !== undefined) {
+    return opts.configuredBasepath
+  }
+
+  if (isFullUrl(opts.publicBase)) {
+    return '/'
+  }
+
+  return opts.publicBase.replace(/^\/|\/$/g, '')
+}
+
+export function shouldRewriteDevBasepath(opts: {
+  command: 'serve' | 'build'
+  middlewareMode: boolean | undefined
+  routerBasepath: string
+  publicBase: string
+}): boolean {
+  if (opts.command !== 'serve' || opts.middlewareMode) {
+    return false
+  }
+
+  return !joinPaths(['/', opts.routerBasepath, '/']).startsWith(
+    joinPaths(['/', opts.publicBase, '/']),
+  )
+}
+
+export function createNormalizedBasePaths(opts: {
+  publicBase: string
+}): NormalizedBasePaths {
+  return {
+    publicBase: opts.publicBase,
+    assetBase: {
+      dev: opts.publicBase,
+      build: opts.publicBase,
+    },
+  }
+}
+
+export function createNormalizedOutputDirectories(opts: {
+  client: string
+  server: string
+}): NormalizedOutputDirectories {
+  return {
+    client: opts.client,
+    server: opts.server,
+  }
+}
+
+export function createServerFnBasePath(opts: {
+  routerBasepath: string
+  serverFnBase: string
+}): string {
+  return joinPaths(['/', opts.routerBasepath, opts.serverFnBase, '/'])
+}
+
+export function resolveStartEntryPlan(opts: {
+  root: string
+  startConfig: TanStackStartOutputConfig
+  defaultEntryPaths: TanStackStartCoreOptions['defaultEntryPaths']
+}): ResolvedStartEntryPlan {
+  const srcDirectory = join(opts.root, opts.startConfig.srcDirectory)
+
+  const startFilePath = resolveEntry({
+    type: 'start entry',
+    configuredEntry: opts.startConfig.start.entry,
+    defaultEntry: 'start',
+    resolvedSrcDirectory: srcDirectory,
+    required: false,
+  })
+
+  const routerFilePath = resolveEntry({
+    type: 'router entry',
+    configuredEntry: opts.startConfig.router.entry,
+    defaultEntry: 'router',
+    resolvedSrcDirectory: srcDirectory,
+    required: true,
+  })
+
+  const clientEntryPath = resolveEntry({
+    type: 'client entry',
+    configuredEntry: opts.startConfig.client.entry,
+    defaultEntry: 'client',
+    resolvedSrcDirectory: srcDirectory,
+    required: false,
+  })
+
+  const serverEntryPath = resolveEntry({
+    type: 'server entry',
+    configuredEntry: opts.startConfig.server.entry,
+    defaultEntry: 'server',
+    resolvedSrcDirectory: srcDirectory,
+    required: false,
+  })
+
+  return {
+    srcDirectory,
+    startFilePath,
+    routerFilePath,
+    entryPaths: {
+      client: clientEntryPath ?? opts.defaultEntryPaths.client,
+      server: serverEntryPath ?? opts.defaultEntryPaths.server,
+      start: startFilePath ?? opts.defaultEntryPaths.start,
+      router: routerFilePath,
+    },
+  }
+}
+
+function isFullUrl(str: string): boolean {
+  try {
+    new URL(str)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/schema.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { z } from 'zod'
 import { configSchema, getConfig } from '@tanstack/router-plugin'
-import type { TanStackStartVitePluginCoreOptions } from './types'
+import type { CompileStartFrameworkOptions } from './types'
 
 const tsrConfig = configSchema
   .omit({ autoCodeSplitting: true, target: true, verboseFileRoutes: true })
@@ -63,7 +63,7 @@ const importProtectionOptionsSchema = z
 
 export function parseStartConfig(
   opts: z.input<typeof tanstackStartOptionsSchema>,
-  corePluginOpts: TanStackStartVitePluginCoreOptions,
+  corePluginOpts: { framework: CompileStartFrameworkOptions },
   root: string,
 ) {
   const options = tanstackStartOptionsSchema.parse(opts)
@@ -180,103 +180,103 @@ const pageSchema = pageBaseSchema.extend({
   prerender: pagePrerenderOptionsSchema.optional(),
 })
 
-const tanstackStartOptionsSchema = z
-  .object({
-    srcDirectory: z.string().optional().default('src'),
-    start: z
-      .object({
-        entry: z.string().optional(),
-      })
-      .optional()
-      .default({}),
-    router: z
-      .object({
-        entry: z.string().optional(),
-        basepath: z.string().optional(),
-      })
-      .and(tsrConfig.optional().default({}))
-      .optional()
-      .default({}),
-    client: z
-      .object({
-        entry: z.string().optional(),
-        base: z.string().optional().default('/_build'),
-      })
-      .optional()
-      .default({}),
-    server: z
-      .object({
-        entry: z.string().optional(),
-        build: z
-          .object({
-            staticNodeEnv: z.boolean().optional().default(true),
-          })
-          .optional()
-          .default({}),
-      })
-      .optional()
-      .default({}),
-    serverFns: z
-      .object({
-        base: z.string().optional().default('/_serverFn'),
-        generateFunctionId: z
-          .function()
-          .args(
-            z.object({
-              filename: z.string(),
-              functionName: z.string(),
-            }),
-          )
-          .returns(z.string().optional())
-          .optional(),
-      })
-      .optional()
-      .default({}),
-    pages: z.array(pageSchema).optional().default([]),
-    sitemap: z
-      .object({
-        enabled: z.boolean().optional().default(true),
-        host: z.string().optional(),
-        outputPath: z.string().optional().default('sitemap.xml'),
-      })
-      .optional(),
-    prerender: z
-      .object({
-        enabled: z.boolean().optional(),
-        concurrency: z.number().optional(),
-        filter: z.function().args(pageSchema).returns(z.any()).optional(),
-        failOnError: z.boolean().optional(),
-        autoStaticPathsDiscovery: z.boolean().optional(),
-        maxRedirects: z.number().min(0).optional(),
-      })
-      .and(pagePrerenderOptionsSchema.optional())
-      .optional(),
-    dev: z
-      .object({
-        ssrStyles: z
-          .object({
-            enabled: z.boolean().optional().default(true),
-            basepath: z.string().optional(),
-          })
-          .optional()
-          .default({}),
-      })
-      .optional()
-      .default({}),
-    spa: spaSchema.optional(),
-    vite: z
-      .object({ installDevServerMiddleware: z.boolean().optional() })
-      .optional(),
-    importProtection: importProtectionOptionsSchema,
-  })
+export const tanstackStartOptionsObjectSchema = z.object({
+  srcDirectory: z.string().optional().default('src'),
+  start: z
+    .object({
+      entry: z.string().optional(),
+    })
+    .optional()
+    .default({}),
+  router: z
+    .object({
+      entry: z.string().optional(),
+      basepath: z.string().optional(),
+    })
+    .and(tsrConfig.optional().default({}))
+    .optional()
+    .default({}),
+  client: z
+    .object({
+      entry: z.string().optional(),
+      base: z.string().optional().default('/_build'),
+    })
+    .optional()
+    .default({}),
+  server: z
+    .object({
+      entry: z.string().optional(),
+      build: z
+        .object({
+          staticNodeEnv: z.boolean().optional().default(true),
+        })
+        .optional()
+        .default({}),
+    })
+    .optional()
+    .default({}),
+  serverFns: z
+    .object({
+      base: z.string().optional().default('/_serverFn'),
+      generateFunctionId: z
+        .function()
+        .args(
+          z.object({
+            filename: z.string(),
+            functionName: z.string(),
+          }),
+        )
+        .returns(z.string().optional())
+        .optional(),
+    })
+    .optional()
+    .default({}),
+  pages: z.array(pageSchema).optional().default([]),
+  sitemap: z
+    .object({
+      enabled: z.boolean().optional().default(true),
+      host: z.string().optional(),
+      outputPath: z.string().optional().default('sitemap.xml'),
+    })
+    .optional(),
+  prerender: z
+    .object({
+      enabled: z.boolean().optional(),
+      concurrency: z.number().optional(),
+      filter: z.function().args(pageSchema).returns(z.any()).optional(),
+      failOnError: z.boolean().optional(),
+      autoStaticPathsDiscovery: z.boolean().optional(),
+      maxRedirects: z.number().min(0).optional(),
+    })
+    .and(pagePrerenderOptionsSchema.optional())
+    .optional(),
+  dev: z
+    .object({
+      ssrStyles: z
+        .object({
+          enabled: z.boolean().optional().default(true),
+          basepath: z.string().optional(),
+        })
+        .optional()
+        .default({}),
+    })
+    .optional()
+    .default({}),
+  spa: spaSchema.optional(),
+  importProtection: importProtectionOptionsSchema,
+})
+
+export const tanstackStartOptionsSchema = tanstackStartOptionsObjectSchema
   .optional()
   .default({})
 
 export type Page = z.infer<typeof pageSchema>
 
-export type TanStackStartInputConfig = z.input<
-  typeof tanstackStartOptionsSchema
+type TanStackStartOptionsInput = NonNullable<
+  z.input<typeof tanstackStartOptionsSchema>
 >
+
+export type TanStackStartInputConfig = TanStackStartOptionsInput
 export type TanStackStartOutputConfig = ReturnType<typeof parseStartConfig>
 
 export type ImportProtectionBehavior = z.infer<

package/src/serialization-adapters-module.ts

@@ -0,0 +1,82 @@
+import type { SerializationAdapterConfig } from './types'
+
+export const EMPTY_SERIALIZATION_ADAPTERS_MODULE = `export const pluginSerializationAdapters = []
+export const hasPluginAdapters = false`
+
+interface ResolvedAdapterModule {
+  module: string
+  export: string
+  isFactory: boolean
+  index: number
+}
+
+export function resolveSerializationAdaptersForRuntime(opts: {
+  adapters: Array<SerializationAdapterConfig> | undefined
+  runtime: 'client' | 'server'
+}): Array<ResolvedAdapterModule> {
+  if (!opts.adapters?.length) {
+    return []
+  }
+
+  const resolvedAdapters: Array<ResolvedAdapterModule> = []
+
+  for (let i = 0; i < opts.adapters.length; i++) {
+    const adapter = opts.adapters[i]!
+
+    if ('module' in adapter) {
+      resolvedAdapters.push({
+        module: adapter.module,
+        export: adapter.export,
+        isFactory: adapter.isFactory ?? true,
+        index: i,
+      })
+      continue
+    }
+
+    const runtimeAdapter =
+      opts.runtime === 'client' ? adapter.client : adapter.server
+
+    if (!runtimeAdapter) {
+      continue
+    }
+
+    resolvedAdapters.push({
+      module: runtimeAdapter.module,
+      export: runtimeAdapter.export,
+      isFactory: runtimeAdapter.isFactory ?? true,
+      index: i,
+    })
+  }
+
+  return resolvedAdapters
+}
+
+export function generateSerializationAdaptersModule(opts: {
+  adapters: Array<SerializationAdapterConfig> | undefined
+  runtime: 'client' | 'server'
+}): string {
+  const resolvedAdapters = resolveSerializationAdaptersForRuntime(opts)
+
+  if (resolvedAdapters.length === 0) {
+    return EMPTY_SERIALIZATION_ADAPTERS_MODULE
+  }
+
+  const imports = resolvedAdapters
+    .map(
+      (adapter) =>
+        `import { ${adapter.export} as adapter${adapter.index} } from '${adapter.module}'`,
+    )
+    .join('\n')
+
+  const items = resolvedAdapters
+    .map((adapter) =>
+      adapter.isFactory
+        ? `...(Array.isArray(adapter${adapter.index}()) ? adapter${adapter.index}() : [adapter${adapter.index}()])`
+        : `adapter${adapter.index}`,
+    )
+    .join(', ')
+
+  return `${imports}
+export const pluginSerializationAdapters = [${items}]
+export const hasPluginAdapters = true`
+}