@tanstack/start-server-core 1.120.3 → 1.120.4-alpha.1

package/dist/cjs/serverRoute.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const routerCore = require("@tanstack/router-core");
+function createServerFileRoute(__) {
+  return createServerRoute();
+}
+function createServerRoute(__, __opts) {
+  const options = __opts || {};
+  const route = {
+    path: "",
+    id: "",
+    fullPath: "",
+    to: "",
+    options,
+    parentRoute: void 0,
+    _types: {},
+    // children: undefined as TChildren,
+    middleware: (middlewares) => createServerRoute(void 0, {
+      ...options,
+      middleware: middlewares
+    }),
+    methods: (methodsOrGetMethods) => {
+      const methods = (() => {
+        if (typeof methodsOrGetMethods === "function") {
+          return methodsOrGetMethods(createMethodBuilder());
+        }
+        return methodsOrGetMethods;
+      })();
+      return createServerRoute(void 0, {
+        ...__opts,
+        methods
+      });
+    },
+    update: (opts) => createServerRoute(void 0, {
+      ...options,
+      ...opts
+    }),
+    init: (opts) => {
+      var _a;
+      options.originalIndex = opts.originalIndex;
+      const isRoot = !options.path && !options.id;
+      route.parentRoute = (_a = options.getParentRoute) == null ? void 0 : _a.call(options);
+      if (isRoot) {
+        route.path = routerCore.rootRouteId;
+      } else if (!route.parentRoute) {
+        throw new Error(
+          `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a ServerRoute instance.`
+        );
+      }
+      let path = isRoot ? routerCore.rootRouteId : options.path;
+      if (path && path !== "/") {
+        path = routerCore.trimPathLeft(path);
+      }
+      const customId = options.id || path;
+      let id = isRoot ? routerCore.rootRouteId : routerCore.joinPaths([
+        route.parentRoute.id === routerCore.rootRouteId ? "" : route.parentRoute.id,
+        customId
+      ]);
+      if (path === routerCore.rootRouteId) {
+        path = "/";
+      }
+      if (id !== routerCore.rootRouteId) {
+        id = routerCore.joinPaths(["/", id]);
+      }
+      const fullPath = id === routerCore.rootRouteId ? "/" : routerCore.joinPaths([route.parentRoute.fullPath, path]);
+      route.path = path;
+      route.id = id;
+      route.fullPath = fullPath;
+      route.to = fullPath;
+    },
+    _addFileChildren: (children) => {
+      if (Array.isArray(children)) {
+        route.children = children;
+      }
+      if (typeof children === "object" && children !== null) {
+        route.children = Object.values(children);
+      }
+      return route;
+    },
+    _addFileTypes: () => route
+  };
+  return route;
+}
+const createMethodBuilder = (__opts) => {
+  return {
+    _options: __opts || {},
+    _types: {},
+    middleware: (middlewares) => createMethodBuilder({
+      ...__opts,
+      middlewares
+    }),
+    handler: (handler) => createMethodBuilder({
+      ...__opts,
+      handler
+    })
+  };
+};
+exports.createServerFileRoute = createServerFileRoute;
+exports.createServerRoute = createServerRoute;
+//# sourceMappingURL=serverRoute.cjs.map

package/dist/cjs/serverRoute.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverRoute.cjs","sources":["../../src/serverRoute.ts"],"sourcesContent":["import { joinPaths, rootRouteId, trimPathLeft } from '@tanstack/router-core'\nimport type {\n  Assign,\n  Constrain,\n  Expand,\n  ResolveParams,\n  RouteConstraints,\n  TrimPathRight,\n} from '@tanstack/router-core'\nimport type {\n  AnyRequestMiddleware,\n  AssignAllServerContext,\n} from '@tanstack/start-client-core'\n\ntype TODO = any\n\nexport function createServerFileRoute<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TChildren,\n>(__?: never): ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren> {\n  return createServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>(\n    undefined,\n  )\n}\n\nexport interface ServerRouteOptions<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n> {\n  id: TId\n  path: TPath\n  pathname: TFullPath\n  originalIndex: number\n  getParentRoute?: () => TParentRoute\n  middleware: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>\n  methods: Record<\n    string,\n    ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, any, any>\n  >\n  caseSensitive?: boolean\n}\n\nexport type ServerRouteManifest = {\n  middleware: boolean\n  methods: Record<string, { middleware: boolean }>\n}\n\nexport function createServerRoute<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TChildren,\n>(\n  __?: never,\n  __opts?: Partial<\n    ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, undefined>\n  >,\n): ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren> {\n  const options = __opts || {}\n\n  const route: ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren> = {\n    path: '' as TPath,\n    id: '' as TId,\n    fullPath: '' as TFullPath,\n    to: '' as TrimPathRight<TFullPath>,\n    options: options as TODO,\n    parentRoute: undefined as unknown as TParentRoute,\n    _types: {} as TODO,\n    // children: undefined as TChildren,\n    middleware: (middlewares: TODO) =>\n      createServerRoute(undefined, {\n        ...options,\n        middleware: middlewares,\n      }) as TODO,\n    methods: (methodsOrGetMethods: TODO) => {\n      const methods = (() => {\n        if (typeof methodsOrGetMethods === 'function') {\n          return methodsOrGetMethods(createMethodBuilder())\n        }\n\n        return methodsOrGetMethods\n      })()\n\n      return createServerRoute(undefined, {\n        ...__opts,\n        methods,\n      }) as TODO\n    },\n    update: (opts) =>\n      createServerRoute(undefined, {\n        ...options,\n        ...opts,\n      }) as TODO,\n    init: (opts: { originalIndex: number }): void => {\n      options.originalIndex = opts.originalIndex\n\n      const isRoot = !options.path && !options.id\n\n      route.parentRoute = options.getParentRoute?.() as TParentRoute\n\n      if (isRoot) {\n        route.path = rootRouteId as TPath\n      } else if (!(route.parentRoute as any)) {\n        throw new Error(\n          `Child Route instances must pass a 'getParentRoute: () => ParentRoute' option that returns a ServerRoute instance.`,\n        )\n      }\n\n      let path: undefined | string = isRoot ? rootRouteId : options.path\n\n      // If the path is anything other than an index path, trim it up\n      if (path && path !== '/') {\n        path = trimPathLeft(path)\n      }\n\n      const customId = options.id || path\n\n      // Strip the parentId prefix from the first level of children\n      let id = isRoot\n        ? rootRouteId\n        : joinPaths([\n            route.parentRoute.id === rootRouteId ? '' : route.parentRoute.id,\n            customId,\n          ])\n\n      if (path === rootRouteId) {\n        path = '/'\n      }\n\n      if (id !== rootRouteId) {\n        id = joinPaths(['/', id])\n      }\n\n      const fullPath =\n        id === rootRouteId ? '/' : joinPaths([route.parentRoute.fullPath, path])\n\n      route.path = path as TPath\n      route.id = id as TId\n      route.fullPath = fullPath as TFullPath\n      route.to = fullPath as TrimPathRight<TFullPath>\n    },\n\n    _addFileChildren: (children) => {\n      if (Array.isArray(children)) {\n        route.children = children as TChildren as TODO\n      }\n\n      if (typeof children === 'object' && children !== null) {\n        route.children = Object.values(children) as TChildren as TODO\n      }\n\n      return route as any\n    },\n\n    _addFileTypes: <TFileTypes>() => route,\n  }\n\n  return route\n}\n\nexport type ServerRouteAddFileChildrenFn<\n  in out TParentRoute extends AnyServerRouteWithTypes,\n  in out TId extends RouteConstraints['TId'],\n  in out TPath extends RouteConstraints['TPath'],\n  in out TFullPath extends RouteConstraints['TFullPath'],\n  in out TMiddlewares,\n  in out TMethods,\n  in out TChildren,\n> = (\n  children: TChildren,\n) => ServerRouteWithTypes<\n  TParentRoute,\n  TId,\n  TPath,\n  TFullPath,\n  TMiddlewares,\n  TMethods,\n  TChildren\n>\n\nconst createMethodBuilder = <\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n>(\n  __opts?: TODO,\n): ServerRouteMethodBuilder<TParentRoute, TFullPath, TMiddlewares> => {\n  return {\n    _options: __opts || {},\n    _types: {} as TODO,\n    middleware: (middlewares) =>\n      createMethodBuilder({\n        ...__opts,\n        middlewares,\n      }) as TODO,\n    handler: (handler) =>\n      createMethodBuilder({\n        ...__opts,\n        handler,\n      }) as TODO,\n  }\n}\n\nexport type CreateServerFileRoute<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TChildren,\n> = (\n  options?: undefined,\n) => ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>\n\nexport type AnyServerRouteWithTypes = ServerRouteWithTypes<\n  any,\n  any,\n  any,\n  any,\n  any,\n  any,\n  any\n>\n\nexport interface ServerRouteWithTypes<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n  TMethods,\n  TChildren,\n> {\n  _types: ServerRouteTypes<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TMiddlewares,\n    TMethods\n  >\n  path: TPath\n  id: TId\n  fullPath: TFullPath\n  to: TrimPathRight<TFullPath>\n  parentRoute: TParentRoute\n  children?: TChildren\n  options: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, TMiddlewares>\n  update: (\n    opts: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, undefined>,\n  ) => ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>\n  init: (opts: { originalIndex: number }) => void\n  _addFileChildren: ServerRouteAddFileChildrenFn<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TMiddlewares,\n    TMethods,\n    TChildren\n  >\n  _addFileTypes: () => ServerRouteWithTypes<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TMiddlewares,\n    TMethods,\n    TChildren\n  >\n}\n\nexport interface ServerRouteTypes<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n  TMethods,\n> {\n  id: TId\n  path: TPath\n  fullPath: TFullPath\n  middlewares: TMiddlewares\n  methods: TMethods\n  parentRoute: TParentRoute\n  allContext: ResolveAllServerContext<TParentRoute, TMiddlewares>\n}\n\nexport type ResolveAllServerContext<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TMiddlewares,\n> = unknown extends TParentRoute\n  ? AssignAllServerContext<TMiddlewares>\n  : Assign<\n      TParentRoute['_types']['allContext'],\n      AssignAllServerContext<TMiddlewares>\n    >\n\nexport type AnyServerRoute = AnyServerRouteWithTypes\n\nexport interface ServerRoute<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TChildren,\n> extends ServerRouteWithTypes<\n      TParentRoute,\n      TId,\n      TPath,\n      TFullPath,\n      undefined,\n      undefined,\n      TChildren\n    >,\n    ServerRouteMiddleware<TParentRoute, TId, TPath, TFullPath, TChildren>,\n    ServerRouteMethods<\n      TParentRoute,\n      TId,\n      TPath,\n      TFullPath,\n      undefined,\n      TChildren\n    > {}\n\nexport interface ServerRouteMiddleware<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TChildren,\n> {\n  middleware: <const TNewMiddleware>(\n    middleware: Constrain<TNewMiddleware, ReadonlyArray<AnyRequestMiddleware>>,\n  ) => ServerRouteAfterMiddleware<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TNewMiddleware,\n    TChildren\n  >\n}\n\nexport interface ServerRouteAfterMiddleware<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n  TChildren,\n> extends ServerRouteWithTypes<\n      TParentRoute,\n      TId,\n      TPath,\n      TFullPath,\n      TMiddlewares,\n      undefined,\n      TChildren\n    >,\n    ServerRouteMethods<\n      TParentRoute,\n      TId,\n      TPath,\n      TFullPath,\n      TMiddlewares,\n      TChildren\n    > {}\n\nexport interface ServerRouteMethods<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n  TChildren,\n> {\n  methods: <const TMethods>(\n    methodsOrGetMethods: Constrain<\n      TMethods,\n      ServerRouteMethodsOptions<TParentRoute, TFullPath, TMiddlewares>\n    >,\n  ) => ServerRouteAfterMethods<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TMiddlewares,\n    TMethods,\n    TChildren\n  >\n}\n\nexport type ServerRouteMethodsOptions<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n> =\n  | ServerRouteMethodsRecord<TParentRoute, TFullPath, TMiddlewares>\n  | ((\n      api: ServerRouteMethodBuilder<TParentRoute, TFullPath, TMiddlewares>,\n    ) => ServerRouteMethodsRecord<TParentRoute, TFullPath, TMiddlewares>)\n\nexport interface ServerRouteMethodsRecord<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n> {\n  GET?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  POST?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  PUT?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  PATCH?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  DELETE?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  OPTIONS?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n  HEAD?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>\n}\n\nexport type ServerRouteMethodRecordValue<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n> =\n  | ServerRouteMethodHandlerFn<\n      TParentRoute,\n      TFullPath,\n      TMiddlewares,\n      undefined,\n      any\n    >\n  | AnyRouteMethodsBuilder\n\nexport type ServerRouteVerb = (typeof ServerRouteVerbs)[number]\n\nexport const ServerRouteVerbs = [\n  'GET',\n  'POST',\n  'PUT',\n  'PATCH',\n  'DELETE',\n  'OPTIONS',\n  'HEAD',\n] as const\n\nexport type ServerRouteMethodHandlerFn<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n  TResponse,\n> = (\n  ctx: ServerRouteMethodHandlerCtx<\n    TParentRoute,\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares\n  >,\n) => TResponse | Promise<TResponse>\n\nexport interface ServerRouteMethodHandlerCtx<\n  in out TParentRoute extends AnyServerRouteWithTypes,\n  in out TFullPath extends string,\n  in out TMiddlewares,\n  in out TMethodMiddlewares,\n> {\n  context: Expand<\n    AssignAllMethodContext<TParentRoute, TMiddlewares, TMethodMiddlewares>\n  >\n  request: Request\n  params: ResolveParams<TFullPath>\n  pathname: TFullPath\n}\n\nexport type MergeMethodMiddlewares<TMiddlewares, TMethodMiddlewares> =\n  TMiddlewares extends ReadonlyArray<any>\n    ? TMethodMiddlewares extends ReadonlyArray<any>\n      ? readonly [...TMiddlewares, ...TMethodMiddlewares]\n      : TMiddlewares\n    : TMethodMiddlewares\n\nexport type AssignAllMethodContext<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TMiddlewares,\n  TMethodMiddlewares,\n> = ResolveAllServerContext<\n  TParentRoute,\n  MergeMethodMiddlewares<TMiddlewares, TMethodMiddlewares>\n>\n\nexport type AnyRouteMethodsBuilder = ServerRouteMethodBuilderWithTypes<\n  any,\n  any,\n  any,\n  any\n>\n\nexport interface ServerRouteMethodBuilder<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n> extends ServerRouteMethodBuilderWithTypes<\n      TFullPath,\n      TMiddlewares,\n      undefined,\n      undefined\n    >,\n    ServerRouteMethodBuilderMiddleware<TParentRoute, TFullPath, TMiddlewares>,\n    ServerRouteMethodBuilderHandler<\n      TParentRoute,\n      TFullPath,\n      TMiddlewares,\n      undefined\n    > {}\n\nexport interface ServerRouteMethodBuilderWithTypes<\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n  TResponse,\n> {\n  _options: TODO\n  _types: ServerRouteMethodBuilderTypes<\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares,\n    TResponse\n  >\n}\n\nexport interface ServerRouteMethodBuilderTypes<\n  in out TFullPath extends string,\n  in out TMiddlewares,\n  in out TMethodMiddlewares,\n  in out TResponse,\n> {\n  middlewares: TMiddlewares\n  methodMiddleware: TMethodMiddlewares\n  fullPath: TFullPath\n  response: TResponse\n}\n\nexport interface ServerRouteMethodBuilderMiddleware<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n> {\n  middleware: <const TNewMethodMiddlewares>(\n    middleware: Constrain<\n      TNewMethodMiddlewares,\n      ReadonlyArray<AnyRequestMiddleware>\n    >,\n  ) => ServerRouteMethodBuilderAfterMiddleware<\n    TParentRoute,\n    TFullPath,\n    TMiddlewares,\n    TNewMethodMiddlewares\n  >\n}\n\nexport interface ServerRouteMethodBuilderAfterMiddleware<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n> extends ServerRouteMethodBuilderWithTypes<\n      TFullPath,\n      TMiddlewares,\n      TMethodMiddlewares,\n      undefined\n    >,\n    ServerRouteMethodBuilderHandler<\n      TParentRoute,\n      TFullPath,\n      TMiddlewares,\n      TMethodMiddlewares\n    > {}\n\nexport interface ServerRouteMethodBuilderHandler<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n> {\n  handler: <TResponse>(\n    handler: ServerRouteMethodHandlerFn<\n      TParentRoute,\n      TFullPath,\n      TMiddlewares,\n      TMethodMiddlewares,\n      TResponse\n    >,\n  ) => ServerRouteMethodBuilderAfterHandler<\n    TParentRoute,\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares,\n    TResponse\n  >\n}\n\nexport interface ServerRouteMethodBuilderAfterHandler<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n  TResponse,\n> extends ServerRouteMethodBuilderWithTypes<\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares,\n    TResponse\n  > {\n  opts: ServerRouteMethod<\n    TParentRoute,\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares\n  >\n}\n\nexport interface ServerRouteMethod<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TFullPath extends string,\n  TMiddlewares,\n  TMethodMiddlewares,\n> {\n  middleware?: Constrain<TMiddlewares, Array<AnyRequestMiddleware>>\n  handler?: ServerRouteMethodHandlerFn<\n    TParentRoute,\n    TFullPath,\n    TMiddlewares,\n    TMethodMiddlewares,\n    undefined\n  >\n}\n\nexport interface ServerRouteAfterMethods<\n  TParentRoute extends AnyServerRouteWithTypes,\n  TId extends RouteConstraints['TId'],\n  TPath extends RouteConstraints['TPath'],\n  TFullPath extends RouteConstraints['TFullPath'],\n  TMiddlewares,\n  TMethods,\n  TChildren,\n> extends ServerRouteWithTypes<\n    TParentRoute,\n    TId,\n    TPath,\n    TFullPath,\n    TMiddlewares,\n    TMethods,\n    TChildren\n  > {\n  options: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, TMiddlewares>\n}\n"],"names":["rootRouteId","trimPathLeft","joinPaths"],"mappings":";;;AAgBO,SAAS,sBAMd,IAAyE;AAClE,SAAA,kBAEP;AACF;AA2BgB,SAAA,kBAOd,IACA,QAG6D;AACvD,QAAA,UAAU,UAAU,CAAC;AAE3B,QAAM,QAAqE;AAAA,IACzE,MAAM;AAAA,IACN,IAAI;AAAA,IACJ,UAAU;AAAA,IACV,IAAI;AAAA,IACJ;AAAA,IACA,aAAa;AAAA,IACb,QAAQ,CAAC;AAAA;AAAA,IAET,YAAY,CAAC,gBACX,kBAAkB,QAAW;AAAA,MAC3B,GAAG;AAAA,MACH,YAAY;AAAA,IAAA,CACb;AAAA,IACH,SAAS,CAAC,wBAA8B;AACtC,YAAM,WAAW,MAAM;AACjB,YAAA,OAAO,wBAAwB,YAAY;AACtC,iBAAA,oBAAoB,qBAAqB;AAAA,QAAA;AAG3C,eAAA;AAAA,MAAA,GACN;AAEH,aAAO,kBAAkB,QAAW;AAAA,QAClC,GAAG;AAAA,QACH;AAAA,MAAA,CACD;AAAA,IACH;AAAA,IACA,QAAQ,CAAC,SACP,kBAAkB,QAAW;AAAA,MAC3B,GAAG;AAAA,MACH,GAAG;AAAA,IAAA,CACJ;AAAA,IACH,MAAM,CAAC,SAA0C;;AAC/C,cAAQ,gBAAgB,KAAK;AAE7B,YAAM,SAAS,CAAC,QAAQ,QAAQ,CAAC,QAAQ;AAEnC,YAAA,eAAc,aAAQ,mBAAR;AAEpB,UAAI,QAAQ;AACV,cAAM,OAAOA,WAAA;AAAA,MAAA,WACJ,CAAE,MAAM,aAAqB;AACtC,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MAAA;AAGE,UAAA,OAA2B,SAASA,WAAA,cAAc,QAAQ;AAG1D,UAAA,QAAQ,SAAS,KAAK;AACxB,eAAOC,wBAAa,IAAI;AAAA,MAAA;AAGpB,YAAA,WAAW,QAAQ,MAAM;AAG3B,UAAA,KAAK,SACLD,WAAA,cACAE,qBAAU;AAAA,QACR,MAAM,YAAY,OAAOF,WAAAA,cAAc,KAAK,MAAM,YAAY;AAAA,QAC9D;AAAA,MAAA,CACD;AAEL,UAAI,SAASA,WAAAA,aAAa;AACjB,eAAA;AAAA,MAAA;AAGT,UAAI,OAAOA,WAAAA,aAAa;AACtB,aAAKE,WAAU,UAAA,CAAC,KAAK,EAAE,CAAC;AAAA,MAAA;AAGpB,YAAA,WACJ,OAAOF,WAAA,cAAc,MAAME,WAAAA,UAAU,CAAC,MAAM,YAAY,UAAU,IAAI,CAAC;AAEzE,YAAM,OAAO;AACb,YAAM,KAAK;AACX,YAAM,WAAW;AACjB,YAAM,KAAK;AAAA,IACb;AAAA,IAEA,kBAAkB,CAAC,aAAa;AAC1B,UAAA,MAAM,QAAQ,QAAQ,GAAG;AAC3B,cAAM,WAAW;AAAA,MAAA;AAGnB,UAAI,OAAO,aAAa,YAAY,aAAa,MAAM;AAC/C,cAAA,WAAW,OAAO,OAAO,QAAQ;AAAA,MAAA;AAGlC,aAAA;AAAA,IACT;AAAA,IAEA,eAAe,MAAkB;AAAA,EACnC;AAEO,SAAA;AACT;AAsBA,MAAM,sBAAsB,CAK1B,WACoE;AAC7D,SAAA;AAAA,IACL,UAAU,UAAU,CAAC;AAAA,IACrB,QAAQ,CAAC;AAAA,IACT,YAAY,CAAC,gBACX,oBAAoB;AAAA,MAClB,GAAG;AAAA,MACH;AAAA,IAAA,CACD;AAAA,IACH,SAAS,CAAC,YACR,oBAAoB;AAAA,MAClB,GAAG;AAAA,MACH;AAAA,IACD,CAAA;AAAA,EACL;AACF;;;"}

package/dist/cjs/serverRoute.d.cts

@@ -0,0 +1,115 @@
+import { Assign, Constrain, Expand, ResolveParams, RouteConstraints, TrimPathRight } from '@tanstack/router-core';
+import { AnyRequestMiddleware, AssignAllServerContext } from '@tanstack/start-client-core';
+type TODO = any;
+export declare function createServerFileRoute<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TChildren>(__?: never): ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>;
+export interface ServerRouteOptions<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares> {
+    id: TId;
+    path: TPath;
+    pathname: TFullPath;
+    originalIndex: number;
+    getParentRoute?: () => TParentRoute;
+    middleware: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>;
+    methods: Record<string, ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, any, any>>;
+    caseSensitive?: boolean;
+}
+export type ServerRouteManifest = {
+    middleware: boolean;
+    methods: Record<string, {
+        middleware: boolean;
+    }>;
+};
+export declare function createServerRoute<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TChildren>(__?: never, __opts?: Partial<ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, undefined>>): ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>;
+export type ServerRouteAddFileChildrenFn<in out TParentRoute extends AnyServerRouteWithTypes, in out TId extends RouteConstraints['TId'], in out TPath extends RouteConstraints['TPath'], in out TFullPath extends RouteConstraints['TFullPath'], in out TMiddlewares, in out TMethods, in out TChildren> = (children: TChildren) => ServerRouteWithTypes<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods, TChildren>;
+export type CreateServerFileRoute<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TChildren> = (options?: undefined) => ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>;
+export type AnyServerRouteWithTypes = ServerRouteWithTypes<any, any, any, any, any, any, any>;
+export interface ServerRouteWithTypes<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares, TMethods, TChildren> {
+    _types: ServerRouteTypes<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods>;
+    path: TPath;
+    id: TId;
+    fullPath: TFullPath;
+    to: TrimPathRight<TFullPath>;
+    parentRoute: TParentRoute;
+    children?: TChildren;
+    options: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, TMiddlewares>;
+    update: (opts: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, undefined>) => ServerRoute<TParentRoute, TId, TPath, TFullPath, TChildren>;
+    init: (opts: {
+        originalIndex: number;
+    }) => void;
+    _addFileChildren: ServerRouteAddFileChildrenFn<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods, TChildren>;
+    _addFileTypes: () => ServerRouteWithTypes<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods, TChildren>;
+}
+export interface ServerRouteTypes<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares, TMethods> {
+    id: TId;
+    path: TPath;
+    fullPath: TFullPath;
+    middlewares: TMiddlewares;
+    methods: TMethods;
+    parentRoute: TParentRoute;
+    allContext: ResolveAllServerContext<TParentRoute, TMiddlewares>;
+}
+export type ResolveAllServerContext<TParentRoute extends AnyServerRouteWithTypes, TMiddlewares> = unknown extends TParentRoute ? AssignAllServerContext<TMiddlewares> : Assign<TParentRoute['_types']['allContext'], AssignAllServerContext<TMiddlewares>>;
+export type AnyServerRoute = AnyServerRouteWithTypes;
+export interface ServerRoute<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TChildren> extends ServerRouteWithTypes<TParentRoute, TId, TPath, TFullPath, undefined, undefined, TChildren>, ServerRouteMiddleware<TParentRoute, TId, TPath, TFullPath, TChildren>, ServerRouteMethods<TParentRoute, TId, TPath, TFullPath, undefined, TChildren> {
+}
+export interface ServerRouteMiddleware<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TChildren> {
+    middleware: <const TNewMiddleware>(middleware: Constrain<TNewMiddleware, ReadonlyArray<AnyRequestMiddleware>>) => ServerRouteAfterMiddleware<TParentRoute, TId, TPath, TFullPath, TNewMiddleware, TChildren>;
+}
+export interface ServerRouteAfterMiddleware<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares, TChildren> extends ServerRouteWithTypes<TParentRoute, TId, TPath, TFullPath, TMiddlewares, undefined, TChildren>, ServerRouteMethods<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TChildren> {
+}
+export interface ServerRouteMethods<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares, TChildren> {
+    methods: <const TMethods>(methodsOrGetMethods: Constrain<TMethods, ServerRouteMethodsOptions<TParentRoute, TFullPath, TMiddlewares>>) => ServerRouteAfterMethods<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods, TChildren>;
+}
+export type ServerRouteMethodsOptions<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares> = ServerRouteMethodsRecord<TParentRoute, TFullPath, TMiddlewares> | ((api: ServerRouteMethodBuilder<TParentRoute, TFullPath, TMiddlewares>) => ServerRouteMethodsRecord<TParentRoute, TFullPath, TMiddlewares>);
+export interface ServerRouteMethodsRecord<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares> {
+    GET?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    POST?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    PUT?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    PATCH?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    DELETE?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    OPTIONS?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+    HEAD?: ServerRouteMethodRecordValue<TParentRoute, TFullPath, TMiddlewares>;
+}
+export type ServerRouteMethodRecordValue<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares> = ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, undefined, any> | AnyRouteMethodsBuilder;
+export type ServerRouteVerb = (typeof ServerRouteVerbs)[number];
+export declare const ServerRouteVerbs: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+export type ServerRouteMethodHandlerFn<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares, TMethodMiddlewares, TResponse> = (ctx: ServerRouteMethodHandlerCtx<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares>) => TResponse | Promise<TResponse>;
+export interface ServerRouteMethodHandlerCtx<in out TParentRoute extends AnyServerRouteWithTypes, in out TFullPath extends string, in out TMiddlewares, in out TMethodMiddlewares> {
+    context: Expand<AssignAllMethodContext<TParentRoute, TMiddlewares, TMethodMiddlewares>>;
+    request: Request;
+    params: ResolveParams<TFullPath>;
+    pathname: TFullPath;
+}
+export type MergeMethodMiddlewares<TMiddlewares, TMethodMiddlewares> = TMiddlewares extends ReadonlyArray<any> ? TMethodMiddlewares extends ReadonlyArray<any> ? readonly [...TMiddlewares, ...TMethodMiddlewares] : TMiddlewares : TMethodMiddlewares;
+export type AssignAllMethodContext<TParentRoute extends AnyServerRouteWithTypes, TMiddlewares, TMethodMiddlewares> = ResolveAllServerContext<TParentRoute, MergeMethodMiddlewares<TMiddlewares, TMethodMiddlewares>>;
+export type AnyRouteMethodsBuilder = ServerRouteMethodBuilderWithTypes<any, any, any, any>;
+export interface ServerRouteMethodBuilder<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares> extends ServerRouteMethodBuilderWithTypes<TFullPath, TMiddlewares, undefined, undefined>, ServerRouteMethodBuilderMiddleware<TParentRoute, TFullPath, TMiddlewares>, ServerRouteMethodBuilderHandler<TParentRoute, TFullPath, TMiddlewares, undefined> {
+}
+export interface ServerRouteMethodBuilderWithTypes<TFullPath extends string, TMiddlewares, TMethodMiddlewares, TResponse> {
+    _options: TODO;
+    _types: ServerRouteMethodBuilderTypes<TFullPath, TMiddlewares, TMethodMiddlewares, TResponse>;
+}
+export interface ServerRouteMethodBuilderTypes<in out TFullPath extends string, in out TMiddlewares, in out TMethodMiddlewares, in out TResponse> {
+    middlewares: TMiddlewares;
+    methodMiddleware: TMethodMiddlewares;
+    fullPath: TFullPath;
+    response: TResponse;
+}
+export interface ServerRouteMethodBuilderMiddleware<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares> {
+    middleware: <const TNewMethodMiddlewares>(middleware: Constrain<TNewMethodMiddlewares, ReadonlyArray<AnyRequestMiddleware>>) => ServerRouteMethodBuilderAfterMiddleware<TParentRoute, TFullPath, TMiddlewares, TNewMethodMiddlewares>;
+}
+export interface ServerRouteMethodBuilderAfterMiddleware<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares, TMethodMiddlewares> extends ServerRouteMethodBuilderWithTypes<TFullPath, TMiddlewares, TMethodMiddlewares, undefined>, ServerRouteMethodBuilderHandler<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares> {
+}
+export interface ServerRouteMethodBuilderHandler<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares, TMethodMiddlewares> {
+    handler: <TResponse>(handler: ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares, TResponse>) => ServerRouteMethodBuilderAfterHandler<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares, TResponse>;
+}
+export interface ServerRouteMethodBuilderAfterHandler<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares, TMethodMiddlewares, TResponse> extends ServerRouteMethodBuilderWithTypes<TFullPath, TMiddlewares, TMethodMiddlewares, TResponse> {
+    opts: ServerRouteMethod<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares>;
+}
+export interface ServerRouteMethod<TParentRoute extends AnyServerRouteWithTypes, TFullPath extends string, TMiddlewares, TMethodMiddlewares> {
+    middleware?: Constrain<TMiddlewares, Array<AnyRequestMiddleware>>;
+    handler?: ServerRouteMethodHandlerFn<TParentRoute, TFullPath, TMiddlewares, TMethodMiddlewares, undefined>;
+}
+export interface ServerRouteAfterMethods<TParentRoute extends AnyServerRouteWithTypes, TId extends RouteConstraints['TId'], TPath extends RouteConstraints['TPath'], TFullPath extends RouteConstraints['TFullPath'], TMiddlewares, TMethods, TChildren> extends ServerRouteWithTypes<TParentRoute, TId, TPath, TFullPath, TMiddlewares, TMethods, TChildren> {
+    options: ServerRouteOptions<TParentRoute, TId, TPath, TFullPath, TMiddlewares>;
+}
+export {};

package/dist/cjs/undici.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const undici = require("undici");
+const __setGlobalOrigin = undici.setGlobalOrigin;
+function __getAbsoluteUrl(req, options = { trustProxy: false }) {
+  const headers = req.headers;
+  const host = options.trustProxy ? headers.get("x-forwarded-host") || headers.get("host") : headers.get("host");
+  const protocol = options.trustProxy ? headers.get("x-forwarded-proto") || "http" : "http";
+  if (!host) throw new Error("Cannot determine host from request headers");
+  return `${protocol}://${host}`;
+}
+exports.__getAbsoluteUrl = __getAbsoluteUrl;
+exports.__setGlobalOrigin = __setGlobalOrigin;
+//# sourceMappingURL=undici.cjs.map

package/dist/cjs/undici.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"undici.cjs","sources":["../../src/undici.ts"],"sourcesContent":["import { setGlobalOrigin } from 'undici'\n\n/**\n * DO NOT USE THIS FUNCTION. THIS FUNCTION IS FOR INTERNAL USE ONLY.\n *\n * @internal\n */\nexport const __setGlobalOrigin = setGlobalOrigin\n\n/**\n * DO NOT USE THIS FUNCTION. THIS FUNCTION IS FOR INTERNAL USE ONLY.\n *\n * Constructs an absolute URL from the given request object and options.\n *\n * @internal\n * @param req - The `Request` object containing the headers to extract the host and protocol.\n * @param options - Configuration options for determining the trust level of proxy headers.\n * @param options.trustProxy - If `true`, the function will trust the `x-forwarded-host` and `x-forwarded-proto` headers\n *                             to determine the host and protocol. Defaults to `false`.\n * @returns The absolute URL constructed from the request headers as a string.\n * @throws Will throw an error if the `host` cannot be determined from the request headers.\n *\n * @example\n * ```ts\n * // Example usage:\n * const req = new Request('http://example.com', {\n *   headers: {\n *     'host': 'example.com',\n *     'x-forwarded-host': 'proxy.example.com',\n *     'x-forwarded-proto': 'https',\n *   },\n * });\n *\n * // Without trusting proxy headers\n * const url1 = getAbsoluteUrl(req);\n * console.log(url1); // Output: \"http://example.com\"\n *\n * // With trusting proxy headers\n * const url2 = getAbsoluteUrl(req, { trustProxy: true });\n * console.log(url2); // Output: \"https://proxy.example.com\"\n * ```\n */\nexport function __getAbsoluteUrl(\n  req: Request,\n  options: { trustProxy: boolean } = { trustProxy: false },\n): string {\n  const headers = req.headers\n\n  const host = options.trustProxy\n    ? headers.get('x-forwarded-host') || headers.get('host')\n    : headers.get('host')\n\n  const protocol = options.trustProxy\n    ? headers.get('x-forwarded-proto') || 'http'\n    : 'http'\n\n  if (!host) throw new Error('Cannot determine host from request headers')\n\n  return `${protocol}://${host}`\n}\n"],"names":["setGlobalOrigin"],"mappings":";;;AAOO,MAAM,oBAAoBA,OAAAA;AAmC1B,SAAS,iBACd,KACA,UAAmC,EAAE,YAAY,SACzC;AACR,QAAM,UAAU,IAAI;AAEpB,QAAM,OAAO,QAAQ,aACjB,QAAQ,IAAI,kBAAkB,KAAK,QAAQ,IAAI,MAAM,IACrD,QAAQ,IAAI,MAAM;AAEtB,QAAM,WAAW,QAAQ,aACrB,QAAQ,IAAI,mBAAmB,KAAK,SACpC;AAEJ,MAAI,CAAC,KAAY,OAAA,IAAI,MAAM,4CAA4C;AAEhE,SAAA,GAAG,QAAQ,MAAM,IAAI;AAC9B;;;"}

package/dist/cjs/undici.d.cts

@@ -0,0 +1,43 @@
+import { setGlobalOrigin } from 'undici';
+/**
+ * DO NOT USE THIS FUNCTION. THIS FUNCTION IS FOR INTERNAL USE ONLY.
+ *
+ * @internal
+ */
+export declare const __setGlobalOrigin: typeof setGlobalOrigin;
+/**
+ * DO NOT USE THIS FUNCTION. THIS FUNCTION IS FOR INTERNAL USE ONLY.
+ *
+ * Constructs an absolute URL from the given request object and options.
+ *
+ * @internal
+ * @param req - The `Request` object containing the headers to extract the host and protocol.
+ * @param options - Configuration options for determining the trust level of proxy headers.
+ * @param options.trustProxy - If `true`, the function will trust the `x-forwarded-host` and `x-forwarded-proto` headers
+ *                             to determine the host and protocol. Defaults to `false`.
+ * @returns The absolute URL constructed from the request headers as a string.
+ * @throws Will throw an error if the `host` cannot be determined from the request headers.
+ *
+ * @example
+ * ```ts
+ * // Example usage:
+ * const req = new Request('http://example.com', {
+ *   headers: {
+ *     'host': 'example.com',
+ *     'x-forwarded-host': 'proxy.example.com',
+ *     'x-forwarded-proto': 'https',
+ *   },
+ * });
+ *
+ * // Without trusting proxy headers
+ * const url1 = getAbsoluteUrl(req);
+ * console.log(url1); // Output: "http://example.com"
+ *
+ * // With trusting proxy headers
+ * const url2 = getAbsoluteUrl(req, { trustProxy: true });
+ * console.log(url2); // Output: "https://proxy.example.com"
+ * ```
+ */
+export declare function __getAbsoluteUrl(req: Request, options?: {
+    trustProxy: boolean;
+}): string;

package/dist/esm/createRequestHandler.js

@@ -40,9 +40,7 @@ function getRequestHeaders(opts) {
   );
   const { redirect } = opts.router.state;
   if (redirect) {
-    headers = mergeHeaders(headers, redirect.headers, {
-      Location: redirect.href
-    });
+    headers = mergeHeaders(headers, redirect.headers);
   }
   return headers;
 }

package/dist/esm/createRequestHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"createRequestHandler.js","sources":["../../src/createRequestHandler.ts"],"sourcesContent":["import { createMemoryHistory } from '@tanstack/history'\nimport { mergeHeaders } from '@tanstack/start-client-core'\nimport { attachRouterServerSsrUtils, dehydrateRouter } from './ssr-server'\nimport type { HandlerCallback } from './handlerCallback'\nimport type { AnyRouter, Manifest } from '@tanstack/router-core'\n\nexport type RequestHandler<TRouter extends AnyRouter> = (\n  cb: HandlerCallback<TRouter>,\n) => Promise<Response>\n\nexport function createRequestHandler<TRouter extends AnyRouter>({\n  createRouter,\n  request,\n  getRouterManifest,\n}: {\n  createRouter: () => TRouter\n  request: Request\n  getRouterManifest?: () => Manifest | Promise<Manifest>\n}): RequestHandler<TRouter> {\n  return async (cb) => {\n    const router = createRouter()\n\n    attachRouterServerSsrUtils(router, await getRouterManifest?.())\n\n    const url = new URL(request.url, 'http://localhost')\n\n    const href = url.href.replace(url.origin, '')\n\n    // Create a history for the router\n    const history = createMemoryHistory({\n      initialEntries: [href],\n    })\n\n    // Update the router with the history and context\n    router.update({\n      history,\n    })\n\n    await router.load()\n\n    dehydrateRouter(router)\n\n    const responseHeaders = getRequestHeaders({\n      router,\n    })\n\n    return cb({\n      request,\n      router,\n      responseHeaders,\n    } as any)\n  }\n}\n\nfunction getRequestHeaders(opts: { router: AnyRouter }): Headers {\n  let headers = mergeHeaders(\n    {\n      'Content-Type': 'text/html; charset=UTF-8',\n    },\n    ...opts.router.state.matches.map((match) => {\n      return match.headers\n    }),\n  )\n\n  // Handle Redirects\n  const { redirect } = opts.router.state\n\n  if (redirect) {\n    headers = mergeHeaders(headers, redirect.headers, {\n      Location: redirect.href,\n    })\n  }\n\n  return headers\n}\n"],"names":[],"mappings":";;;AAUO,SAAS,qBAAgD;AAAA,EAC9D;AAAA,EACA;AAAA,EACA;AACF,GAI4B;AAC1B,SAAO,OAAO,OAAO;AACnB,UAAM,SAAS,aAAa;AAED,+BAAA,QAAQ,OAAM,yDAAqB;AAE9D,UAAM,MAAM,IAAI,IAAI,QAAQ,KAAK,kBAAkB;AAEnD,UAAM,OAAO,IAAI,KAAK,QAAQ,IAAI,QAAQ,EAAE;AAG5C,UAAM,UAAU,oBAAoB;AAAA,MAClC,gBAAgB,CAAC,IAAI;AAAA,IAAA,CACtB;AAGD,WAAO,OAAO;AAAA,MACZ;AAAA,IAAA,CACD;AAED,UAAM,OAAO,KAAK;AAElB,oBAAgB,MAAM;AAEtB,UAAM,kBAAkB,kBAAkB;AAAA,MACxC;AAAA,IAAA,CACD;AAED,WAAO,GAAG;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IAAA,CACM;AAAA,EACV;AACF;AAEA,SAAS,kBAAkB,MAAsC;AAC/D,MAAI,UAAU;AAAA,IACZ;AAAA,MACE,gBAAgB;AAAA,IAClB;AAAA,IACA,GAAG,KAAK,OAAO,MAAM,QAAQ,IAAI,CAAC,UAAU;AAC1C,aAAO,MAAM;AAAA,IACd,CAAA;AAAA,EACH;AAGA,QAAM,EAAE,SAAA,IAAa,KAAK,OAAO;AAEjC,MAAI,UAAU;AACF,cAAA,aAAa,SAAS,SAAS,SAAS;AAAA,MAChD,UAAU,SAAS;AAAA,IAAA,CACpB;AAAA,EAAA;AAGI,SAAA;AACT;"}
+{"version":3,"file":"createRequestHandler.js","sources":["../../src/createRequestHandler.ts"],"sourcesContent":["import { createMemoryHistory } from '@tanstack/history'\nimport { mergeHeaders } from '@tanstack/start-client-core'\nimport { attachRouterServerSsrUtils, dehydrateRouter } from './ssr-server'\nimport type { HandlerCallback } from './handlerCallback'\nimport type { AnyRouter, Manifest } from '@tanstack/router-core'\n\nexport type RequestHandler<TRouter extends AnyRouter> = (\n  cb: HandlerCallback<TRouter>,\n) => Promise<Response>\n\nexport function createRequestHandler<TRouter extends AnyRouter>({\n  createRouter,\n  request,\n  getRouterManifest,\n}: {\n  createRouter: () => TRouter\n  request: Request\n  getRouterManifest?: () => Manifest | Promise<Manifest>\n}): RequestHandler<TRouter> {\n  return async (cb) => {\n    const router = createRouter()\n\n    attachRouterServerSsrUtils(router, await getRouterManifest?.())\n\n    const url = new URL(request.url, 'http://localhost')\n\n    const href = url.href.replace(url.origin, '')\n\n    // Create a history for the router\n    const history = createMemoryHistory({\n      initialEntries: [href],\n    })\n\n    // Update the router with the history and context\n    router.update({\n      history,\n    })\n\n    await router.load()\n\n    dehydrateRouter(router)\n\n    const responseHeaders = getRequestHeaders({\n      router,\n    })\n\n    return cb({\n      request,\n      router,\n      responseHeaders,\n    } as any)\n  }\n}\n\nfunction getRequestHeaders(opts: { router: AnyRouter }): Headers {\n  let headers = mergeHeaders(\n    {\n      'Content-Type': 'text/html; charset=UTF-8',\n    },\n    ...opts.router.state.matches.map((match) => {\n      return match.headers\n    }),\n  )\n\n  // Handle Redirects\n  const { redirect } = opts.router.state\n\n  if (redirect) {\n    headers = mergeHeaders(headers, redirect.headers)\n  }\n\n  return headers\n}\n"],"names":[],"mappings":";;;AAUO,SAAS,qBAAgD;AAAA,EAC9D;AAAA,EACA;AAAA,EACA;AACF,GAI4B;AAC1B,SAAO,OAAO,OAAO;AACnB,UAAM,SAAS,aAAa;AAED,+BAAA,QAAQ,OAAM,yDAAqB;AAE9D,UAAM,MAAM,IAAI,IAAI,QAAQ,KAAK,kBAAkB;AAEnD,UAAM,OAAO,IAAI,KAAK,QAAQ,IAAI,QAAQ,EAAE;AAG5C,UAAM,UAAU,oBAAoB;AAAA,MAClC,gBAAgB,CAAC,IAAI;AAAA,IAAA,CACtB;AAGD,WAAO,OAAO;AAAA,MACZ;AAAA,IAAA,CACD;AAED,UAAM,OAAO,KAAK;AAElB,oBAAgB,MAAM;AAEtB,UAAM,kBAAkB,kBAAkB;AAAA,MACxC;AAAA,IAAA,CACD;AAED,WAAO,GAAG;AAAA,MACR;AAAA,MACA;AAAA,MACA;AAAA,IAAA,CACM;AAAA,EACV;AACF;AAEA,SAAS,kBAAkB,MAAsC;AAC/D,MAAI,UAAU;AAAA,IACZ;AAAA,MACE,gBAAgB;AAAA,IAClB;AAAA,IACA,GAAG,KAAK,OAAO,MAAM,QAAQ,IAAI,CAAC,UAAU;AAC1C,aAAO,MAAM;AAAA,IACd,CAAA;AAAA,EACH;AAGA,QAAM,EAAE,SAAA,IAAa,KAAK,OAAO;AAEjC,MAAI,UAAU;AACF,cAAA,aAAa,SAAS,SAAS,OAAO;AAAA,EAAA;AAG3C,SAAA;AACT;"}

package/dist/esm/createStartHandler.d.ts

@@ -1,8 +1,10 @@
-import { eventHandler, EventHandlerResponse } from 'h3';
+import { RequestHandler } from './h3.js';
+import { AnyRouter } from '@tanstack/router-core';
 import { HandlerCallback } from './handlerCallback.js';
-import { AnyRouter, Manifest } from '@tanstack/router-core';
-export type CustomizeStartHandler<TRouter extends AnyRouter, TResponse extends EventHandlerResponse = EventHandlerResponse> = (cb: HandlerCallback<TRouter, TResponse>) => ReturnType<typeof eventHandler>;
-export declare function createStartHandler<TRouter extends AnyRouter, TResponse extends EventHandlerResponse = EventHandlerResponse>({ createRouter, getRouterManifest, }: {
+export type CustomizeStartHandler<TRouter extends AnyRouter> = (cb: HandlerCallback<TRouter>) => RequestHandler;
+export declare function getStartResponseHeaders(opts: {
+    router: AnyRouter;
+}): Headers;
+export declare function createStartHandler<TRouter extends AnyRouter>({ createRouter, }: {
     createRouter: () => TRouter;
-    getRouterManifest?: () => Manifest | Promise<Manifest>;
-}): CustomizeStartHandler<TRouter, TResponse>;
+}): CustomizeStartHandler<TRouter>;

package/dist/esm/createStartHandler.js

@@ -1,56 +1,232 @@
+import path from "node:path";
 import { createMemoryHistory } from "@tanstack/history";
-import { mergeHeaders } from "@tanstack/start-client-core";
-import { eventHandler, toWebRequest, getResponseHeaders } from "h3";
+import { mergeHeaders, json, flattenMiddlewares } from "@tanstack/start-client-core";
+import { isRedirect, tsrRedirectHeaderKey, processRouteTree, getMatchedRoutes, rootRouteId } from "@tanstack/router-core";
+import { getResponseHeaders, requestHandler } from "./h3.js";
 import { attachRouterServerSsrUtils, dehydrateRouter } from "./ssr-server.js";
+import { getStartManifest } from "./router-manifest.js";
+import { handleServerAction } from "./server-functions-handler.js";
+function getStartResponseHeaders(opts) {
+  let headers = mergeHeaders(
+    getResponseHeaders(),
+    {
+      "Content-Type": "text/html; charset=UTF-8"
+    },
+    ...opts.router.state.matches.map((match) => {
+      return match.headers;
+    })
+  );
+  const { redirect } = opts.router.state;
+  if (redirect) {
+    headers = mergeHeaders(headers, redirect.headers);
+  }
+  return headers;
+}
 function createStartHandler({
-  createRouter,
-  getRouterManifest
+  createRouter
 }) {
   return (cb) => {
-    return eventHandler(async (event) => {
-      const request = toWebRequest(event);
+    return requestHandler(async ({ request }) => {
       const url = new URL(request.url);
       const href = url.href.replace(url.origin, "");
       const history = createMemoryHistory({
         initialEntries: [href]
       });
       const router = createRouter();
-      attachRouterServerSsrUtils(router, await (getRouterManifest == null ? void 0 : getRouterManifest()));
+      attachRouterServerSsrUtils(router, getStartManifest());
       router.update({
         history
       });
-      await router.load();
-      dehydrateRouter(router);
-      const responseHeaders = getStartResponseHeaders({ event, router });
-      const response = await cb({
-        request,
-        router,
-        responseHeaders
-      });
+      const response = await (async () => {
+        try {
+          if (!process.env.TSS_SERVER_FN_BASE) {
+            throw new Error(
+              "tanstack/start-server-core: TSS_SERVER_FN_BASE must be defined in your environment for createStartHandler()"
+            );
+          }
+          if (href.startsWith(path.join("/", process.env.TSS_SERVER_FN_BASE, "/"))) {
+            return await handleServerAction({ request });
+          }
+          const serverRouteTreeModule = await (async () => {
+            try {
+              return await import("tanstack:server-routes");
+            } catch (e) {
+              console.log(e);
+              return void 0;
+            }
+          })();
+          if (serverRouteTreeModule) {
+            const [matchedRoutes, response3] = await handleServerRoutes({
+              routeTree: serverRouteTreeModule.routeTree,
+              request
+            });
+            if (response3) return response3;
+          }
+          const requestAcceptHeader = request.headers.get("Accept") || "*/*";
+          const splitRequestAcceptHeader = requestAcceptHeader.split(",");
+          const supportedMimeTypes = ["*/*", "text/html"];
+          const isRouterAcceptSupported = supportedMimeTypes.some(
+            (mimeType) => splitRequestAcceptHeader.some(
+              (acceptedMimeType) => acceptedMimeType.trim().startsWith(mimeType)
+            )
+          );
+          if (!isRouterAcceptSupported) {
+            return json(
+              {
+                error: "Only HTML requests are supported here"
+              },
+              {
+                status: 500
+              }
+            );
+          }
+          await router.load();
+          if (router.state.redirect) return router.state.redirect;
+          dehydrateRouter(router);
+          const responseHeaders = getStartResponseHeaders({ router });
+          const response2 = await cb({
+            request,
+            router,
+            responseHeaders
+          });
+          return response2;
+        } catch (err) {
+          if (err instanceof Response) {
+            return err;
+          }
+          throw err;
+        }
+      })();
+      if (isRedirect(response)) {
+        if (response.options.to && typeof response.options.to === "string" && !response.options.to.startsWith("/")) {
+          throw new Error(
+            `Server side redirects must use absolute paths via the 'href' or 'to' options. Received: ${JSON.stringify(response.options)}`
+          );
+        }
+        if (["params", "search", "hash"].some(
+          (d) => typeof response.options[d] === "function"
+        )) {
+          throw new Error(
+            `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
+              response.options
+            ).filter((d) => typeof response.options[d] === "function").map((d) => `"${d}"`).join(", ")}`
+          );
+        }
+        const redirect = router.resolveRedirect(response);
+        if (request.headers.get("x-tsr-redirect") === "manual") {
+          return json(
+            {
+              ...response.options,
+              isSerializedRedirect: true
+            },
+            {
+              headers: redirect.headers
+            }
+          );
+        }
+        return redirect;
+      }
+      response.headers.append(
+        "Access-Control-Expose-Headers",
+        tsrRedirectHeaderKey
+      );
       return response;
     });
   };
 }
-function getStartResponseHeaders(opts) {
-  let headers = mergeHeaders(
-    getResponseHeaders(opts.event),
-    opts.event.___ssrRpcResponseHeaders,
-    {
-      "Content-Type": "text/html; charset=UTF-8"
-    },
-    ...opts.router.state.matches.map((match) => {
-      return match.headers;
-    })
-  );
-  const { redirect } = opts.router.state;
-  if (redirect) {
-    headers = mergeHeaders(headers, redirect.headers, {
-      Location: redirect.href
+async function handleServerRoutes({
+  routeTree,
+  request
+}) {
+  const { flatRoutes, routesById, routesByPath } = processRouteTree({
+    routeTree,
+    initRoute: (route, i) => {
+      route.init({
+        originalIndex: i
+      });
+    }
+  });
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const history = createMemoryHistory({
+    initialEntries: [pathname]
+  });
+  const { matchedRoutes, foundRoute, routeParams } = getMatchedRoutes({
+    pathname: history.location.pathname,
+    basepath: "/",
+    caseSensitive: true,
+    routesByPath,
+    routesById,
+    flatRoutes
+  });
+  let response;
+  if (foundRoute && foundRoute.id !== rootRouteId) {
+    const method = Object.keys(foundRoute.options.methods).find(
+      (method2) => method2.toLowerCase() === request.method.toLowerCase()
+    );
+    if (method) {
+      const handler = foundRoute.options.methods[method];
+      if (handler) {
+        const middlewares = flattenMiddlewares(
+          matchedRoutes.flatMap((r) => r.options.middleware).filter(Boolean)
+        ).map((d) => d.options.server);
+        middlewares.push(handlerToMiddleware(handler));
+        const ctx = await executeMiddleware(middlewares, {
+          request,
+          context: {},
+          params: routeParams,
+          pathname: history.location.pathname
+        });
+        response = ctx.response;
+      }
+    }
+  }
+  return [matchedRoutes, response];
+}
+function handlerToMiddleware(handler) {
+  return async ({ next, ...rest }) => ({
+    response: await handler(rest)
+  });
+}
+function executeMiddleware(middlewares, ctx) {
+  let index = -1;
+  const next = async (ctx2) => {
+    index++;
+    const middleware = middlewares[index];
+    if (!middleware) return ctx2;
+    const result = await middleware({
+      ...ctx2,
+      // Allow the middleware to call the next middleware in the chain
+      next: async (nextCtx) => {
+        const nextResult = await next({ ...ctx2, ...nextCtx });
+        return Object.assign(ctx2, handleCtxResult(nextResult));
+      }
+      // Allow the middleware result to extend the return context
+    }).catch((err) => {
+      if (isSpecialResponse(err)) {
+        return {
+          response: err
+        };
+      }
+      throw err;
     });
+    return Object.assign(ctx2, handleCtxResult(result));
+  };
+  return handleCtxResult(next(ctx));
+}
+function handleCtxResult(result) {
+  if (isSpecialResponse(result)) {
+    return {
+      response: result
+    };
   }
-  return headers;
+  return result;
+}
+function isSpecialResponse(err) {
+  return err instanceof Response || isRedirect(err);
 }
 export {
-  createStartHandler
+  createStartHandler,
+  getStartResponseHeaders
 };
 //# sourceMappingURL=createStartHandler.js.map