@@ -0,0 +1,5 @@
+---
+'@tanstack/start-plugin-core': patch
+---
+
+Stop resolving top-level calls such as `z.object()` whose receiver is not a namespace import. They can never be a `createServerOnlyFn` or `createClientOnlyFn` call, and resolving them made the dev compiler load and parse the receiver's module (all of zod, for example).
@@ -425,6 +425,31 @@ function isTopLevelDirectCallCandidate(
   )
 }
 
+/**
+ * Whether the call is `receiver.method()` with a receiver that is not a
+ * namespace import, e.g. `z.object()` with `import { z } from 'zod'`.
+ *
+ * Resolution gives such a call the kind of the receiver itself, which only
+ * yields a direct-call candidate when the receiver is a factory and the code
+ * calls one of its properties (`createServerOnlyFn.bind()`). Skipping these
+ * calls saves loading the receiver's module (all of zod, here) only to learn
+ * that `z` is not a Start factory.
+ */
+function isMemberCallOnNonNamespaceReceiver(
+  node: t.CallExpression,
+  bindings: Map<string, Binding>,
+): boolean {
+  if (
+    !t.isMemberExpression(node.callee) ||
+    !t.isIdentifier(node.callee.object)
+  ) {
+    return false
+  }
+
+  const binding = bindings.get(node.callee.object.name)
+  return !(binding?.type === 'import' && binding.importedName === '*')
+}
+
 function isDirectCallCandidateForKind(
   kind: Exclude<LookupKind, 'ClientOnlyJSX'>,
   externalLookupSetup?: Map<ExternalLookupKind, DirectCallSetup>,
@@ -1125,7 +1150,13 @@ export class StartCompiler {
                     }
                   }
 
-                  if (isTopLevelDirectCallCandidate(path)) {
+                  if (
+                    isTopLevelDirectCallCandidate(path) &&
+                    !isMemberCallOnNonNamespaceReceiver(
+                      node,
+                      moduleInfo.bindings,
+                    )
+                  ) {
                     candidatePaths.push({ path })
                   }
                 },
@@ -1172,7 +1203,11 @@ export class StartCompiler {
               }
             }
 
-            if (checkDirectCalls && isTopLevelDirectCallCandidate(path)) {
+            if (
+              checkDirectCalls &&
+              isTopLevelDirectCallCandidate(path) &&
+              !isMemberCallOnNonNamespaceReceiver(node, moduleInfo.bindings)
+            ) {
               candidatePaths.push({ path })
               return
             }
 
@@ -1407,6 +1407,129 @@ export const factory = createServerFn().middleware([middleware]);`
   ).resolves.toBeNull()
 })
 
+describe.each(['build', 'dev'] as const)(
+  'top-level member calls in %s mode',
+  (mode) => {
+    function createCompilerWithModules(
+      env: 'client' | 'server',
+      virtualModules: Record<string, string>,
+    ) {
+      const resolved: Array<string> = []
+      const loaded: Array<string> = []
+      const compiler: StartCompiler = new StartCompiler({
+        ...getDefaultTestOptions(env),
+        env,
+        mode,
+        devServerFnModuleSpecifierEncoder: ({ extractedFilename, root }) =>
+          `/@id${extractedFilename.slice(root.length)}`,
+        lookupKinds: getLookupKindsForEnv(env),
+        lookupConfigurations: getLookupConfigurationsForEnv(env, 'react'),
+        getKnownServerFns: () => ({}),
+        resolveId: async (id) => {
+          resolved.push(id)
+          return id in virtualModules ? id : null
+        },
+        loadModule: async (id) => {
+          loaded.push(id)
+          const code = virtualModules[id]
+          if (code) {
+            compiler.ingestModule({ code, id })
+          }
+        },
+      })
+      return { compiler, resolved, loaded }
+    }
+
+    describe.each(['fast', 'full'] as const)('%s traversal', (traversal) => {
+      // An isomorphic function requires full traversal; server functions alone
+      // use the compiler's fast path. Let normal code detection choose the path.
+      const traversalCode =
+        traversal === 'full'
+          ? `import { createIsomorphicFn } from '@tanstack/react-start'
+         export const iso = createIsomorphicFn().client(() => 'client').server(() => 'server')`
+          : ''
+
+      test.each(['client', 'ssr', 'provider'] as const)(
+        'does not resolve or load named-import receivers in %s output',
+        async (output) => {
+          const env = output === 'client' ? 'client' : 'server'
+          const { compiler, resolved, loaded } = createCompilerWithModules(
+            env,
+            {
+              zod: `export const z = { object: (shape) => shape, string: () => ({}) }`,
+              './api': `export const api = { users: () => [] }`,
+            },
+          )
+          const code = `
+      ${traversalCode}
+      import { createServerFn } from '@tanstack/react-start'
+      import { z } from 'zod'
+      import { api } from './api'
+
+      const Input = z.object({ id: z.string() })
+      const users = api.users()
+
+      export const getUser = createServerFn()
+        .validator(Input)
+        .handler(async ({ data }) => ({ id: data.id, users }))
+    `
+
+          const result = await compiler.compile({
+            id:
+              '/test/get-user.ts' +
+              (output === 'provider' ? '?tss-serverfn-split' : ''),
+            code,
+            detectedKinds: detectKindsInCode(code, env),
+          })
+
+          expect(result).not.toBeNull()
+          const rpc = {
+            client: 'createClientRpc',
+            ssr: 'createSsrRpc',
+            provider: 'createServerRpc',
+          }
+          expect(result!.code).toContain(rpc[output])
+          expect(resolved).toEqual([])
+          expect(loaded).toEqual([])
+        },
+      )
+
+      test.each(['client', 'server'] as const)(
+        'still compiles a renamed env-only factory called through a namespace import on %s',
+        async (env) => {
+          const { compiler } = createCompilerWithModules(env, {
+            './factory': `export { createServerOnlyFn as serverOnly } from '@tanstack/start-fn-stubs'`,
+          })
+          const code = `
+        ${traversalCode}
+        import { createServerFn } from '@tanstack/react-start'
+        import * as factory from './factory'
+
+        export const impl = factory.serverOnly(() => 'server-only-value')
+
+        export const fn = createServerFn().handler(async () => impl())
+      `
+
+          const result = await compiler.compile({
+            id: '/test/namespace-factory.ts',
+            code,
+            detectedKinds: detectKindsInCode(code, env),
+          })
+
+          expect(result).not.toBeNull()
+          if (env === 'server') {
+            expect(result!.code).toContain('server-only-value')
+            expect(result!.code).not.toContain('factory.serverOnly')
+          } else {
+            expect(result!.code).not.toContain('server-only-value')
+            expect(result!.code).toContain('throw new Error')
+          }
+        },
+      )
+    })
+  },
+)
+
 test.each([
   `(createServerOnlyFn)(() => 'server-value')`,
   `(createIsomorphicFn)().server(() => 'server-value').client(() => 'client-value')`,
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +'@tanstack/start-plugin-core': patch
 +---
++
 +Stop resolving top-level calls such as `z.object()` whose receiver is not a namespace import. They can never be a `createServerOnlyFn` or `createClientOnlyFn` call, and resolving them made the dev compiler load and parse the receiver's module (all of zod, for example).