@tanstack/start-plugin-core 1.142.4 → 1.142.6

package/dist/esm/create-server-fn-plugin/handleCreateServerFn.js

@@ -1,53 +1,50 @@
 import * as t from "@babel/types";
-import { getRootCallExpression, codeFrameError } from "../start-compiler-plugin/utils.js";
-function handleCreateServerFn(path, opts) {
-  const validMethods = ["middleware", "inputValidator", "handler"];
-  const callExpressionPaths = {
-    middleware: null,
-    inputValidator: null,
-    handler: null
-  };
-  const rootCallExpression = getRootCallExpression(path);
-  if (!rootCallExpression.parentPath.isVariableDeclarator()) {
+import { codeFrameError } from "../start-compiler-plugin/utils.js";
+function handleCreateServerFn(candidate, opts) {
+  const { path, methodChain } = candidate;
+  const { inputValidator, handler } = methodChain;
+  if (!path.parentPath.isVariableDeclarator()) {
     throw new Error("createServerFn must be assigned to a variable!");
   }
-  const variableDeclarator = rootCallExpression.parentPath.node;
+  const variableDeclarator = path.parentPath.node;
+  if (!t.isIdentifier(variableDeclarator.id)) {
+    throw codeFrameError(
+      opts.code,
+      variableDeclarator.id.loc,
+      "createServerFn must be assigned to a simple identifier, not a destructuring pattern"
+    );
+  }
   const existingVariableName = variableDeclarator.id.name;
-  rootCallExpression.traverse({
-    MemberExpression(memberExpressionPath) {
-      if (t.isIdentifier(memberExpressionPath.node.property)) {
-        const name = memberExpressionPath.node.property.name;
-        if (validMethods.includes(name) && memberExpressionPath.parentPath.isCallExpression()) {
-          callExpressionPaths[name] = memberExpressionPath.parentPath;
-        }
-      }
-    }
-  });
-  if (callExpressionPaths.inputValidator) {
-    const innerInputExpression = callExpressionPaths.inputValidator.node.arguments[0];
+  if (inputValidator) {
+    const innerInputExpression = inputValidator.callPath.node.arguments[0];
     if (!innerInputExpression) {
       throw new Error(
         "createServerFn().inputValidator() must be called with a validator!"
       );
     }
     if (opts.env === "client") {
-      if (t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)) {
-        callExpressionPaths.inputValidator.replaceWith(
-          callExpressionPaths.inputValidator.node.callee.object
+      if (t.isMemberExpression(inputValidator.callPath.node.callee)) {
+        inputValidator.callPath.replaceWith(
+          inputValidator.callPath.node.callee.object
         );
       }
     }
   }
-  const handlerFnPath = callExpressionPaths.handler?.get(
-    "arguments.0"
-  );
-  if (!callExpressionPaths.handler || !handlerFnPath.node) {
+  const handlerFnPath = handler?.firstArgPath;
+  if (!handler || !handlerFnPath?.node) {
     throw codeFrameError(
       opts.code,
       path.node.callee.loc,
       `createServerFn must be called with a "handler" property!`
     );
   }
+  if (!t.isExpression(handlerFnPath.node)) {
+    throw codeFrameError(
+      opts.code,
+      handlerFnPath.node.loc,
+      `handler() must be called with an expression, not a ${handlerFnPath.node.type}`
+    );
+  }
   const handlerFn = handlerFnPath.node;
   if (t.isIdentifier(handlerFn)) {
     if (opts.env === "client") {
@@ -76,7 +73,7 @@ function handleCreateServerFn(path, opts) {
     )
   );
   if (opts.env === "server" && opts.isProviderFile) {
-    callExpressionPaths.handler.node.arguments.push(handlerFn);
+    handler.callPath.node.arguments.push(handlerFn);
   }
 }
 export {

package/dist/esm/create-server-fn-plugin/handleCreateServerFn.js.map

@@ -1 +1 @@
-{"version":3,"file":"handleCreateServerFn.js","sources":["../../../src/create-server-fn-plugin/handleCreateServerFn.ts"],"sourcesContent":["import * as t from '@babel/types'\nimport {\n  codeFrameError,\n  getRootCallExpression,\n} from '../start-compiler-plugin/utils'\nimport type * as babel from '@babel/core'\n\nexport function handleCreateServerFn(\n  path: babel.NodePath<t.CallExpression>,\n  opts: {\n    env: 'client' | 'server'\n    code: string\n    directive: string\n    /**\n     * Whether this file is a provider file (extracted server function file).\n     * Only provider files should have the handler implementation as a second argument.\n     */\n    isProviderFile: boolean\n  },\n) {\n  // Traverse the member expression and find the call expressions for\n  // the validator, handler, and middleware methods. Check to make sure they\n  // are children of the createServerFn call expression.\n\n  const validMethods = ['middleware', 'inputValidator', 'handler'] as const\n  type ValidMethods = (typeof validMethods)[number]\n  const callExpressionPaths: Record<\n    ValidMethods,\n    babel.NodePath<t.CallExpression> | null\n  > = {\n    middleware: null,\n    inputValidator: null,\n    handler: null,\n  }\n\n  const rootCallExpression = getRootCallExpression(path)\n\n  // if (debug)\n  //   console.info(\n  //     'Handling createServerFn call expression:',\n  //     rootCallExpression.toString(),\n  //   )\n\n  // Check if the call is assigned to a variable\n  if (!rootCallExpression.parentPath.isVariableDeclarator()) {\n    throw new Error('createServerFn must be assigned to a variable!')\n  }\n\n  // Get the identifier name of the variable\n  const variableDeclarator = rootCallExpression.parentPath.node\n  const existingVariableName = (variableDeclarator.id as t.Identifier).name\n\n  rootCallExpression.traverse({\n    MemberExpression(memberExpressionPath) {\n      if (t.isIdentifier(memberExpressionPath.node.property)) {\n        const name = memberExpressionPath.node.property.name as ValidMethods\n\n        if (\n          validMethods.includes(name) &&\n          memberExpressionPath.parentPath.isCallExpression()\n        ) {\n          callExpressionPaths[name] = memberExpressionPath.parentPath\n        }\n      }\n    },\n  })\n\n  if (callExpressionPaths.inputValidator) {\n    const innerInputExpression =\n      callExpressionPaths.inputValidator.node.arguments[0]\n\n    if (!innerInputExpression) {\n      throw new Error(\n        'createServerFn().inputValidator() must be called with a validator!',\n      )\n    }\n\n    // If we're on the client, remove the validator call expression\n    if (opts.env === 'client') {\n      if (\n        t.isMemberExpression(callExpressionPaths.inputValidator.node.callee)\n      ) {\n        callExpressionPaths.inputValidator.replaceWith(\n          callExpressionPaths.inputValidator.node.callee.object,\n        )\n      }\n    }\n  }\n\n  // First, we need to move the handler function to a nested function call\n  // that is applied to the arguments passed to the server function.\n\n  const handlerFnPath = callExpressionPaths.handler?.get(\n    'arguments.0',\n  ) as babel.NodePath<any>\n\n  if (!callExpressionPaths.handler || !handlerFnPath.node) {\n    throw codeFrameError(\n      opts.code,\n      path.node.callee.loc!,\n      `createServerFn must be called with a \"handler\" property!`,\n    )\n  }\n\n  const handlerFn = handlerFnPath.node\n\n  // So, the way we do this is we give the handler function a way\n  // to access the serverFn ctx on the server via function scope.\n  // The 'use server' extracted function will be called with the\n  // payload from the client, then use the scoped serverFn ctx\n  // to execute the handler function.\n  // This way, we can do things like data and middleware validation\n  // in the __execute function without having to AST transform the\n  // handler function too much itself.\n\n  // .handler((optsOut, ctx) => {\n  //   return ((optsIn) => {\n  //     'use server'\n  //     ctx.__execute(handlerFn, optsIn)\n  //   })(optsOut)\n  // })\n\n  // If the handler function is an identifier and we're on the client, we need to\n  // remove the bound function from the file.\n  // If we're on the server, you can leave it, since it will get referenced\n  // as a second argument.\n\n  if (t.isIdentifier(handlerFn)) {\n    if (opts.env === 'client') {\n      // Find the binding for the handler function\n      const binding = handlerFnPath.scope.getBinding(handlerFn.name)\n      // Remove it\n      if (binding) {\n        binding.path.remove()\n      }\n    }\n    // If the env is server, just leave it alone\n  }\n\n  handlerFnPath.replaceWith(\n    t.arrowFunctionExpression(\n      [t.identifier('opts'), t.identifier('signal')],\n      t.blockStatement(\n        // Everything in here is server-only, since the client\n        // will strip out anything in the 'use server' directive.\n        [\n          t.returnStatement(\n            t.callExpression(\n              t.identifier(`${existingVariableName}.__executeServer`),\n              [t.identifier('opts'), t.identifier('signal')],\n            ),\n          ),\n        ],\n        [t.directive(t.directiveLiteral(opts.directive))],\n      ),\n    ),\n  )\n\n  // Add the serverFn as a second argument on the server side,\n  // but ONLY for provider files (extracted server function files).\n  // Caller files must NOT have the second argument because the implementation is already available in the extracted chunk\n  // and including it would duplicate code\n  if (opts.env === 'server' && opts.isProviderFile) {\n    callExpressionPaths.handler.node.arguments.push(handlerFn)\n  }\n}\n"],"names":[],"mappings":";;AAOO,SAAS,qBACd,MACA,MAUA;AAKA,QAAM,eAAe,CAAC,cAAc,kBAAkB,SAAS;AAE/D,QAAM,sBAGF;AAAA,IACF,YAAY;AAAA,IACZ,gBAAgB;AAAA,IAChB,SAAS;AAAA,EAAA;AAGX,QAAM,qBAAqB,sBAAsB,IAAI;AASrD,MAAI,CAAC,mBAAmB,WAAW,wBAAwB;AACzD,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AAGA,QAAM,qBAAqB,mBAAmB,WAAW;AACzD,QAAM,uBAAwB,mBAAmB,GAAoB;AAErE,qBAAmB,SAAS;AAAA,IAC1B,iBAAiB,sBAAsB;AACrC,UAAI,EAAE,aAAa,qBAAqB,KAAK,QAAQ,GAAG;AACtD,cAAM,OAAO,qBAAqB,KAAK,SAAS;AAEhD,YACE,aAAa,SAAS,IAAI,KAC1B,qBAAqB,WAAW,oBAChC;AACA,8BAAoB,IAAI,IAAI,qBAAqB;AAAA,QACnD;AAAA,MACF;AAAA,IACF;AAAA,EAAA,CACD;AAED,MAAI,oBAAoB,gBAAgB;AACtC,UAAM,uBACJ,oBAAoB,eAAe,KAAK,UAAU,CAAC;AAErD,QAAI,CAAC,sBAAsB;AACzB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAGA,QAAI,KAAK,QAAQ,UAAU;AACzB,UACE,EAAE,mBAAmB,oBAAoB,eAAe,KAAK,MAAM,GACnE;AACA,4BAAoB,eAAe;AAAA,UACjC,oBAAoB,eAAe,KAAK,OAAO;AAAA,QAAA;AAAA,MAEnD;AAAA,IACF;AAAA,EACF;AAKA,QAAM,gBAAgB,oBAAoB,SAAS;AAAA,IACjD;AAAA,EAAA;AAGF,MAAI,CAAC,oBAAoB,WAAW,CAAC,cAAc,MAAM;AACvD,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,KAAK,KAAK,OAAO;AAAA,MACjB;AAAA,IAAA;AAAA,EAEJ;AAEA,QAAM,YAAY,cAAc;AAuBhC,MAAI,EAAE,aAAa,SAAS,GAAG;AAC7B,QAAI,KAAK,QAAQ,UAAU;AAEzB,YAAM,UAAU,cAAc,MAAM,WAAW,UAAU,IAAI;AAE7D,UAAI,SAAS;AACX,gBAAQ,KAAK,OAAA;AAAA,MACf;AAAA,IACF;AAAA,EAEF;AAEA,gBAAc;AAAA,IACZ,EAAE;AAAA,MACA,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,MAC7C,EAAE;AAAA;AAAA;AAAA,QAGA;AAAA,UACE,EAAE;AAAA,YACA,EAAE;AAAA,cACA,EAAE,WAAW,GAAG,oBAAoB,kBAAkB;AAAA,cACtD,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,YAAA;AAAA,UAC/C;AAAA,QACF;AAAA,QAEF,CAAC,EAAE,UAAU,EAAE,iBAAiB,KAAK,SAAS,CAAC,CAAC;AAAA,MAAA;AAAA,IAClD;AAAA,EACF;AAOF,MAAI,KAAK,QAAQ,YAAY,KAAK,gBAAgB;AAChD,wBAAoB,QAAQ,KAAK,UAAU,KAAK,SAAS;AAAA,EAC3D;AACF;"}
+{"version":3,"file":"handleCreateServerFn.js","sources":["../../../src/create-server-fn-plugin/handleCreateServerFn.ts"],"sourcesContent":["import * as t from '@babel/types'\nimport { codeFrameError } from '../start-compiler-plugin/utils'\nimport type { RewriteCandidate } from './types'\n\n/**\n * Handles createServerFn transformations.\n *\n * @param candidate - The rewrite candidate containing path and method chain\n * @param opts - Options including the environment, code, directive, and provider file flag\n */\nexport function handleCreateServerFn(\n  candidate: RewriteCandidate,\n  opts: {\n    env: 'client' | 'server'\n    code: string\n    directive: string\n    /**\n     * Whether this file is a provider file (extracted server function file).\n     * Only provider files should have the handler implementation as a second argument.\n     */\n    isProviderFile: boolean\n  },\n) {\n  const { path, methodChain } = candidate\n  const { inputValidator, handler } = methodChain\n\n  // Check if the call is assigned to a variable\n  if (!path.parentPath.isVariableDeclarator()) {\n    throw new Error('createServerFn must be assigned to a variable!')\n  }\n\n  // Get the identifier name of the variable\n  const variableDeclarator = path.parentPath.node\n  if (!t.isIdentifier(variableDeclarator.id)) {\n    throw codeFrameError(\n      opts.code,\n      variableDeclarator.id.loc!,\n      'createServerFn must be assigned to a simple identifier, not a destructuring pattern',\n    )\n  }\n  const existingVariableName = variableDeclarator.id.name\n\n  if (inputValidator) {\n    const innerInputExpression = inputValidator.callPath.node.arguments[0]\n\n    if (!innerInputExpression) {\n      throw new Error(\n        'createServerFn().inputValidator() must be called with a validator!',\n      )\n    }\n\n    // If we're on the client, remove the validator call expression\n    if (opts.env === 'client') {\n      if (t.isMemberExpression(inputValidator.callPath.node.callee)) {\n        inputValidator.callPath.replaceWith(\n          inputValidator.callPath.node.callee.object,\n        )\n      }\n    }\n  }\n\n  // First, we need to move the handler function to a nested function call\n  // that is applied to the arguments passed to the server function.\n\n  const handlerFnPath = handler?.firstArgPath\n\n  if (!handler || !handlerFnPath?.node) {\n    throw codeFrameError(\n      opts.code,\n      path.node.callee.loc!,\n      `createServerFn must be called with a \"handler\" property!`,\n    )\n  }\n\n  // Validate the handler argument is an expression (not a SpreadElement, etc.)\n  if (!t.isExpression(handlerFnPath.node)) {\n    throw codeFrameError(\n      opts.code,\n      handlerFnPath.node.loc!,\n      `handler() must be called with an expression, not a ${handlerFnPath.node.type}`,\n    )\n  }\n\n  const handlerFn = handlerFnPath.node\n\n  // So, the way we do this is we give the handler function a way\n  // to access the serverFn ctx on the server via function scope.\n  // The 'use server' extracted function will be called with the\n  // payload from the client, then use the scoped serverFn ctx\n  // to execute the handler function.\n  // This way, we can do things like data and middleware validation\n  // in the __execute function without having to AST transform the\n  // handler function too much itself.\n\n  // .handler((optsOut, ctx) => {\n  //   return ((optsIn) => {\n  //     'use server'\n  //     ctx.__execute(handlerFn, optsIn)\n  //   })(optsOut)\n  // })\n\n  // If the handler function is an identifier and we're on the client, we need to\n  // remove the bound function from the file.\n  // If we're on the server, you can leave it, since it will get referenced\n  // as a second argument.\n\n  if (t.isIdentifier(handlerFn)) {\n    if (opts.env === 'client') {\n      // Find the binding for the handler function\n      const binding = handlerFnPath.scope.getBinding(handlerFn.name)\n      // Remove it\n      if (binding) {\n        binding.path.remove()\n      }\n    }\n    // If the env is server, just leave it alone\n  }\n\n  handlerFnPath.replaceWith(\n    t.arrowFunctionExpression(\n      [t.identifier('opts'), t.identifier('signal')],\n      t.blockStatement(\n        // Everything in here is server-only, since the client\n        // will strip out anything in the 'use server' directive.\n        [\n          t.returnStatement(\n            t.callExpression(\n              t.identifier(`${existingVariableName}.__executeServer`),\n              [t.identifier('opts'), t.identifier('signal')],\n            ),\n          ),\n        ],\n        [t.directive(t.directiveLiteral(opts.directive))],\n      ),\n    ),\n  )\n\n  // Add the serverFn as a second argument on the server side,\n  // but ONLY for provider files (extracted server function files).\n  // Caller files must NOT have the second argument because the implementation is already available in the extracted chunk\n  // and including it would duplicate code\n  if (opts.env === 'server' && opts.isProviderFile) {\n    handler.callPath.node.arguments.push(handlerFn)\n  }\n}\n"],"names":[],"mappings":";;AAUO,SAAS,qBACd,WACA,MAUA;AACA,QAAM,EAAE,MAAM,YAAA,IAAgB;AAC9B,QAAM,EAAE,gBAAgB,QAAA,IAAY;AAGpC,MAAI,CAAC,KAAK,WAAW,wBAAwB;AAC3C,UAAM,IAAI,MAAM,gDAAgD;AAAA,EAClE;AAGA,QAAM,qBAAqB,KAAK,WAAW;AAC3C,MAAI,CAAC,EAAE,aAAa,mBAAmB,EAAE,GAAG;AAC1C,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,mBAAmB,GAAG;AAAA,MACtB;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,uBAAuB,mBAAmB,GAAG;AAEnD,MAAI,gBAAgB;AAClB,UAAM,uBAAuB,eAAe,SAAS,KAAK,UAAU,CAAC;AAErE,QAAI,CAAC,sBAAsB;AACzB,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAGA,QAAI,KAAK,QAAQ,UAAU;AACzB,UAAI,EAAE,mBAAmB,eAAe,SAAS,KAAK,MAAM,GAAG;AAC7D,uBAAe,SAAS;AAAA,UACtB,eAAe,SAAS,KAAK,OAAO;AAAA,QAAA;AAAA,MAExC;AAAA,IACF;AAAA,EACF;AAKA,QAAM,gBAAgB,SAAS;AAE/B,MAAI,CAAC,WAAW,CAAC,eAAe,MAAM;AACpC,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,KAAK,KAAK,OAAO;AAAA,MACjB;AAAA,IAAA;AAAA,EAEJ;AAGA,MAAI,CAAC,EAAE,aAAa,cAAc,IAAI,GAAG;AACvC,UAAM;AAAA,MACJ,KAAK;AAAA,MACL,cAAc,KAAK;AAAA,MACnB,sDAAsD,cAAc,KAAK,IAAI;AAAA,IAAA;AAAA,EAEjF;AAEA,QAAM,YAAY,cAAc;AAuBhC,MAAI,EAAE,aAAa,SAAS,GAAG;AAC7B,QAAI,KAAK,QAAQ,UAAU;AAEzB,YAAM,UAAU,cAAc,MAAM,WAAW,UAAU,IAAI;AAE7D,UAAI,SAAS;AACX,gBAAQ,KAAK,OAAA;AAAA,MACf;AAAA,IACF;AAAA,EAEF;AAEA,gBAAc;AAAA,IACZ,EAAE;AAAA,MACA,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,MAC7C,EAAE;AAAA;AAAA;AAAA,QAGA;AAAA,UACE,EAAE;AAAA,YACA,EAAE;AAAA,cACA,EAAE,WAAW,GAAG,oBAAoB,kBAAkB;AAAA,cACtD,CAAC,EAAE,WAAW,MAAM,GAAG,EAAE,WAAW,QAAQ,CAAC;AAAA,YAAA;AAAA,UAC/C;AAAA,QACF;AAAA,QAEF,CAAC,EAAE,UAAU,EAAE,iBAAiB,KAAK,SAAS,CAAC,CAAC;AAAA,MAAA;AAAA,IAClD;AAAA,EACF;AAOF,MAAI,KAAK,QAAQ,YAAY,KAAK,gBAAgB;AAChD,YAAQ,SAAS,KAAK,UAAU,KAAK,SAAS;AAAA,EAChD;AACF;"}

package/dist/esm/create-server-fn-plugin/types.d.ts

@@ -0,0 +1,31 @@
+import type * as babel from '@babel/core';
+import type * as t from '@babel/types';
+/**
+ * Info about a method call in the chain, including the call expression path
+ * and the path to its first argument (if any).
+ */
+export interface MethodCallInfo {
+    callPath: babel.NodePath<t.CallExpression>;
+    /** Path to the first argument, or null if no arguments */
+    firstArgPath: babel.NodePath | null;
+}
+/**
+ * Pre-collected method chain paths for a root call expression.
+ * This avoids needing to traverse the AST again in handlers.
+ */
+export interface MethodChainPaths {
+    middleware: MethodCallInfo | null;
+    inputValidator: MethodCallInfo | null;
+    handler: MethodCallInfo | null;
+    server: MethodCallInfo | null;
+    client: MethodCallInfo | null;
+}
+export type MethodChainKey = keyof MethodChainPaths;
+export declare const METHOD_CHAIN_KEYS: ReadonlyArray<MethodChainKey>;
+/**
+ * Information about a candidate that needs to be rewritten.
+ */
+export interface RewriteCandidate {
+    path: babel.NodePath<t.CallExpression>;
+    methodChain: MethodChainPaths;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/start-plugin-core",
-  "version": "1.142.4",
+  "version": "1.142.6",
   "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -59,13 +59,13 @@
     "vitefu": "^1.1.1",
     "xmlbuilder2": "^4.0.0",
     "zod": "^3.24.2",
-    "@tanstack/router-core": "1.141.8",
-    "@tanstack/router-generator": "1.142.0",
-    "@tanstack/router-plugin": "1.142.0",
+    "@tanstack/router-core": "1.142.6",
+    "@tanstack/router-plugin": "1.142.6",
+    "@tanstack/router-generator": "1.142.6",
     "@tanstack/router-utils": "1.141.0",
     "@tanstack/server-functions-plugin": "1.142.1",
-    "@tanstack/start-client-core": "1.142.1",
-    "@tanstack/start-server-core": "1.142.4"
+    "@tanstack/start-client-core": "1.142.6",
+    "@tanstack/start-server-core": "1.142.6"
   },
   "devDependencies": {
     "@types/babel__code-frame": "^7.0.6",

package/src/create-server-fn-plugin/compiler.ts

@@ -8,6 +8,7 @@ import {
 } from 'babel-dead-code-elimination'
 import { handleCreateServerFn } from './handleCreateServerFn'
 import { handleCreateMiddleware } from './handleCreateMiddleware'
+import type { MethodChainPaths, RewriteCandidate } from './types'
 
 type Binding =
   | {
@@ -41,6 +42,16 @@ const LookupSetup: Record<
   },
 }
 
+// Pre-computed map: identifier name -> LookupKind for fast candidate detection
+const IdentifierToKind = new Map<string, LookupKind>()
+for (const [kind, setup] of Object.entries(LookupSetup) as Array<
+  [LookupKind, { candidateCallIdentifier: Set<string> }]
+>) {
+  for (const id of setup.candidateCallIdentifier) {
+    IdentifierToKind.set(id, kind)
+  }
+}
+
 export type LookupConfig = {
   libName: string
   rootExport: string
@@ -59,6 +70,10 @@ export class ServerFnCompiler {
   private moduleCache = new Map<string, ModuleInfo>()
   private initialized = false
   private validLookupKinds: Set<LookupKind>
+  // Fast lookup for direct imports from known libraries (e.g., '@tanstack/react-start')
+  // Maps: libName → (exportName → Kind)
+  // This allows O(1) resolution for the common case without async resolveId calls
+  private knownRootImports = new Map<string, Map<string, Kind>>()
   constructor(
     private options: {
       env: 'client' | 'server'
@@ -108,6 +123,14 @@ export class ServerFnCompiler {
           resolvedKind: `Root` satisfies Kind,
         })
         this.moduleCache.set(libId, rootModule)
+
+        // Also populate the fast lookup map for direct imports
+        let libExports = this.knownRootImports.get(config.libName)
+        if (!libExports) {
+          libExports = new Map()
+          this.knownRootImports.set(config.libName, libExports)
+        }
+        libExports.set(config.rootExport, 'Root')
       }),
     )
 
@@ -247,36 +270,98 @@ export class ServerFnCompiler {
     }
 
     // let's find out which of the candidates are actually server functions
-    const toRewrite: Array<{
-      callExpression: t.CallExpression
-      kind: LookupKind
-    }> = []
-    for (const handler of candidates) {
-      const kind = await this.resolveExprKind(handler, id)
+    // Resolve all candidates in parallel for better performance
+    const resolvedCandidates = await Promise.all(
+      candidates.map(async (candidate) => ({
+        candidate,
+        kind: await this.resolveExprKind(candidate, id),
+      })),
+    )
+
+    // Map from candidate/root node -> kind
+    // Note: For top-level variable declarations, candidate === root (the outermost CallExpression)
+    const toRewriteMap = new Map<t.CallExpression, LookupKind>()
+    for (const { candidate, kind } of resolvedCandidates) {
       if (this.validLookupKinds.has(kind as LookupKind)) {
-        toRewrite.push({ callExpression: handler, kind: kind as LookupKind })
+        toRewriteMap.set(candidate, kind as LookupKind)
       }
     }
-    if (toRewrite.length === 0) {
+    if (toRewriteMap.size === 0) {
       return null
     }
 
+    // Single-pass traversal to find NodePaths and collect method chains
     const pathsToRewrite: Array<{
-      nodePath: babel.NodePath<t.CallExpression>
+      path: babel.NodePath<t.CallExpression>
       kind: LookupKind
+      methodChain: MethodChainPaths
     }> = []
+
+    // First, collect all CallExpression paths in the AST for O(1) lookup
+    const callExprPaths = new Map<
+      t.CallExpression,
+      babel.NodePath<t.CallExpression>
+    >()
+
     babel.traverse(ast, {
       CallExpression(path) {
-        const found = toRewrite.findIndex((h) => path.node === h.callExpression)
-        if (found !== -1) {
-          pathsToRewrite.push({ nodePath: path, kind: toRewrite[found]!.kind })
-          // delete from toRewrite
-          toRewrite.splice(found, 1)
-        }
+        callExprPaths.set(path.node, path)
       },
     })
 
-    if (toRewrite.length > 0) {
+    // Now process candidates - we can look up any CallExpression path in O(1)
+    for (const [node, kind] of toRewriteMap) {
+      const path = callExprPaths.get(node)
+      if (!path) {
+        continue
+      }
+
+      // Collect method chain paths by walking DOWN from root through the chain
+      const methodChain: MethodChainPaths = {
+        middleware: null,
+        inputValidator: null,
+        handler: null,
+        server: null,
+        client: null,
+      }
+
+      // Walk down the call chain using nodes, look up paths from map
+      let currentNode: t.CallExpression = node
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      while (true) {
+        const callee = currentNode.callee
+        if (!t.isMemberExpression(callee)) {
+          break
+        }
+
+        // Record method chain path if it's a known method
+        if (t.isIdentifier(callee.property)) {
+          const name = callee.property.name as keyof MethodChainPaths
+          if (name in methodChain) {
+            const currentPath = callExprPaths.get(currentNode)!
+            // Get first argument path
+            const args = currentPath.get('arguments')
+            const firstArgPath =
+              Array.isArray(args) && args.length > 0 ? (args[0] ?? null) : null
+            methodChain[name] = {
+              callPath: currentPath,
+              firstArgPath,
+            }
+          }
+        }
+
+        // Move to the inner call (the object of the member expression)
+        if (!t.isCallExpression(callee.object)) {
+          break
+        }
+        currentNode = callee.object
+      }
+
+      pathsToRewrite.push({ path, kind, methodChain })
+    }
+
+    // Verify we found all candidates (pathsToRewrite should have same size as toRewriteMap had)
+    if (pathsToRewrite.length !== toRewriteMap.size) {
       throw new Error(
         `Internal error: could not find all paths to rewrite. please file an issue`,
       )
@@ -284,18 +369,21 @@ export class ServerFnCompiler {
 
     const refIdents = findReferencedIdentifiers(ast)
 
-    pathsToRewrite.map((p) => {
-      if (p.kind === 'ServerFn') {
-        handleCreateServerFn(p.nodePath, {
+    for (const { path, kind, methodChain } of pathsToRewrite) {
+      const candidate: RewriteCandidate = { path, methodChain }
+      if (kind === 'ServerFn') {
+        handleCreateServerFn(candidate, {
           env: this.options.env,
           code,
           directive: this.options.directive,
           isProviderFile,
         })
       } else {
-        handleCreateMiddleware(p.nodePath, { env: this.options.env })
+        handleCreateMiddleware(candidate, {
+          env: this.options.env,
+        })
       }
-    })
+    }
 
     deadCodeElimination(ast, refIdents)
 
@@ -312,12 +400,12 @@ export class ServerFnCompiler {
 
     for (const binding of bindings.values()) {
       if (binding.type === 'var') {
-        const handler = isCandidateCallExpression(
+        const candidate = isCandidateCallExpression(
           binding.init,
           this.validLookupKinds,
         )
-        if (handler) {
-          candidates.push(handler)
+        if (candidate) {
+          candidates.push(candidate)
         }
       }
     }
@@ -352,6 +440,61 @@ export class ServerFnCompiler {
     return resolvedKind
   }
 
+  /**
+   * Recursively find an export in a module, following `export * from` chains.
+   * Returns the module info and binding if found, or undefined if not found.
+   */
+  private async findExportInModule(
+    moduleInfo: ModuleInfo,
+    exportName: string,
+    visitedModules = new Set<string>(),
+  ): Promise<{ moduleInfo: ModuleInfo; binding: Binding } | undefined> {
+    // Prevent infinite loops in circular re-exports
+    if (visitedModules.has(moduleInfo.id)) {
+      return undefined
+    }
+    visitedModules.add(moduleInfo.id)
+
+    // First check direct exports
+    const directExport = moduleInfo.exports.get(exportName)
+    if (directExport) {
+      const binding = moduleInfo.bindings.get(directExport.name)
+      if (binding) {
+        return { moduleInfo, binding }
+      }
+    }
+
+    // If not found, recursively check re-export-all sources in parallel
+    // Valid code won't have duplicate exports across chains, so first match wins
+    if (moduleInfo.reExportAllSources.length > 0) {
+      const results = await Promise.all(
+        moduleInfo.reExportAllSources.map(async (reExportSource) => {
+          const reExportTarget = await this.options.resolveId(
+            reExportSource,
+            moduleInfo.id,
+          )
+          if (reExportTarget) {
+            const reExportModule = await this.getModuleInfo(reExportTarget)
+            return this.findExportInModule(
+              reExportModule,
+              exportName,
+              visitedModules,
+            )
+          }
+          return undefined
+        }),
+      )
+      // Return the first valid result
+      for (const result of results) {
+        if (result) {
+          return result
+        }
+      }
+    }
+
+    return undefined
+  }
+
   private async resolveBindingKind(
     binding: Binding,
     fileId: string,
@@ -361,6 +504,19 @@ export class ServerFnCompiler {
       return binding.resolvedKind
     }
     if (binding.type === 'import') {
+      // Fast path: check if this is a direct import from a known library
+      // (e.g., import { createServerFn } from '@tanstack/react-start')
+      // This avoids async resolveId calls for the common case
+      const knownExports = this.knownRootImports.get(binding.source)
+      if (knownExports) {
+        const kind = knownExports.get(binding.importedName)
+        if (kind) {
+          binding.resolvedKind = kind
+          return kind
+        }
+      }
+
+      // Slow path: resolve through the module graph
       const target = await this.options.resolveId(binding.source, fileId)
       if (!target) {
         return 'None'
@@ -368,60 +524,28 @@ export class ServerFnCompiler {
 
       const importedModule = await this.getModuleInfo(target)
 
-      // Try to find the export in the module's direct exports
-      const moduleExport = importedModule.exports.get(binding.importedName)
-
-      // If not found directly, check re-export-all sources (`export * from './module'`)
-      if (!moduleExport && importedModule.reExportAllSources.length > 0) {
-        for (const reExportSource of importedModule.reExportAllSources) {
-          const reExportTarget = await this.options.resolveId(
-            reExportSource,
-            importedModule.id,
-          )
-          if (reExportTarget) {
-            const reExportModule = await this.getModuleInfo(reExportTarget)
-            const reExportEntry = reExportModule.exports.get(
-              binding.importedName,
-            )
-            if (reExportEntry) {
-              // Found the export in a re-exported module, resolve from there
-              const reExportBinding = reExportModule.bindings.get(
-                reExportEntry.name,
-              )
-              if (reExportBinding) {
-                if (reExportBinding.resolvedKind) {
-                  return reExportBinding.resolvedKind
-                }
-                const resolvedKind = await this.resolveBindingKind(
-                  reExportBinding,
-                  reExportModule.id,
-                  visited,
-                )
-                reExportBinding.resolvedKind = resolvedKind
-                return resolvedKind
-              }
-            }
-          }
-        }
-      }
+      // Find the export, recursively searching through export * from chains
+      const found = await this.findExportInModule(
+        importedModule,
+        binding.importedName,
+      )
 
-      if (!moduleExport) {
+      if (!found) {
         return 'None'
       }
-      const importedBinding = importedModule.bindings.get(moduleExport.name)
-      if (!importedBinding) {
-        return 'None'
-      }
-      if (importedBinding.resolvedKind) {
-        return importedBinding.resolvedKind
+
+      const { moduleInfo: foundModule, binding: foundBinding } = found
+
+      if (foundBinding.resolvedKind) {
+        return foundBinding.resolvedKind
       }
 
       const resolvedKind = await this.resolveBindingKind(
-        importedBinding,
-        importedModule.id,
+        foundBinding,
+        foundModule.id,
         visited,
       )
-      importedBinding.resolvedKind = resolvedKind
+      foundBinding.resolvedKind = resolvedKind
       return resolvedKind
     }
 
@@ -443,6 +567,15 @@ export class ServerFnCompiler {
       return 'None'
     }
 
+    // Unwrap common TypeScript/parenthesized wrappers first for efficiency
+    while (
+      t.isTSAsExpression(expr) ||
+      t.isTSNonNullExpression(expr) ||
+      t.isParenthesizedExpression(expr)
+    ) {
+      expr = expr.expression
+    }
+
     let result: Kind = 'None'
 
     if (t.isCallExpression(expr)) {
@@ -454,15 +587,12 @@ export class ServerFnCompiler {
         fileId,
         visited,
       )
-      if (calleeKind !== 'None') {
-        if (calleeKind === `Root` || calleeKind === `Builder`) {
-          return `Builder`
-        }
-        for (const kind of this.validLookupKinds) {
-          if (calleeKind === kind) {
-            return kind
-          }
-        }
+      if (calleeKind === 'Root' || calleeKind === 'Builder') {
+        return 'Builder'
+      }
+      // Use direct Set.has() instead of iterating
+      if (this.validLookupKinds.has(calleeKind as LookupKind)) {
+        return calleeKind
       }
     } else if (t.isMemberExpression(expr) && t.isIdentifier(expr.property)) {
       result = await this.resolveCalleeKind(expr.object, fileId, visited)
@@ -472,16 +602,6 @@ export class ServerFnCompiler {
       result = await this.resolveIdentifierKind(expr.name, fileId, visited)
     }
 
-    if (result === 'None' && t.isTSAsExpression(expr)) {
-      result = await this.resolveExprKind(expr.expression, fileId, visited)
-    }
-    if (result === 'None' && t.isTSNonNullExpression(expr)) {
-      result = await this.resolveExprKind(expr.expression, fileId, visited)
-    }
-    if (result === 'None' && t.isParenthesizedExpression(expr)) {
-      result = await this.resolveExprKind(expr.expression, fileId, visited)
-    }
-
     return result
   }
 
@@ -576,17 +696,18 @@ export class ServerFnCompiler {
 function isCandidateCallExpression(
   node: t.Node | null | undefined,
   lookupKinds: Set<LookupKind>,
-): undefined | t.CallExpression {
+): t.CallExpression | undefined {
   if (!t.isCallExpression(node)) return undefined
 
   const callee = node.callee
   if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.property)) {
     return undefined
   }
-  for (const kind of lookupKinds) {
-    if (LookupSetup[kind].candidateCallIdentifier.has(callee.property.name)) {
-      return node
-    }
+
+  // Use pre-computed map for O(1) lookup instead of iterating over lookupKinds
+  const kind = IdentifierToKind.get(callee.property.name)
+  if (kind && lookupKinds.has(kind)) {
+    return node
   }
 
   return undefined