@benjavicente/start-client-core 1.167.9

package/dist/esm/getStartContextServerOnly.js

@@ -0,0 +1,8 @@
+import { createServerOnlyFn } from "@benjavicente/start-fn-stubs";
+import { getStartContext } from "@benjavicente/start-storage-context";
+//#region src/getStartContextServerOnly.ts
+var getStartContextServerOnly = createServerOnlyFn(getStartContext);
+//#endregion
+export { getStartContextServerOnly };
+
+//# sourceMappingURL=getStartContextServerOnly.js.map

package/dist/esm/getStartContextServerOnly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStartContextServerOnly.js","names":[],"sources":["../../src/getStartContextServerOnly.ts"],"sourcesContent":["import { getStartContext } from '@benjavicente/start-storage-context'\nimport { createServerOnlyFn } from '@benjavicente/start-fn-stubs'\n\nexport const getStartContextServerOnly = createServerOnlyFn(getStartContext)\n"],"mappings":";;;AAGA,IAAa,4BAA4B,mBAAmB,gBAAgB"}

package/dist/esm/getStartOptions.d.ts

@@ -0,0 +1,2 @@
+import { AnyStartInstanceOptions } from './createStart.js';
+export declare const getStartOptions: () => AnyStartInstanceOptions | undefined;

package/dist/esm/getStartOptions.js

@@ -0,0 +1,8 @@
+import { createIsomorphicFn } from "@benjavicente/start-fn-stubs";
+import { getStartContext } from "@benjavicente/start-storage-context";
+//#region src/getStartOptions.ts
+var getStartOptions = createIsomorphicFn().client(() => window.__TSS_START_OPTIONS__).server(() => getStartContext().startOptions);
+//#endregion
+export { getStartOptions };
+
+//# sourceMappingURL=getStartOptions.js.map

package/dist/esm/getStartOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStartOptions.js","names":[],"sources":["../../src/getStartOptions.ts"],"sourcesContent":["import { getStartContext } from '@benjavicente/start-storage-context'\nimport { createIsomorphicFn } from '@benjavicente/start-fn-stubs'\nimport type { AnyStartInstanceOptions } from './createStart'\n\nexport const getStartOptions: () => AnyStartInstanceOptions | undefined =\n  createIsomorphicFn()\n    .client(() => window.__TSS_START_OPTIONS__)\n    .server(() => getStartContext().startOptions)\n"],"mappings":";;;AAIA,IAAa,kBACX,oBAAoB,CACjB,aAAa,OAAO,sBAAsB,CAC1C,aAAa,iBAAiB,CAAC,aAAa"}

package/dist/esm/global.d.ts

@@ -0,0 +1,7 @@
+import { AnyStartInstanceOptions } from './createStart.js';
+declare global {
+    interface Window {
+        __TSS_START_OPTIONS__?: AnyStartInstanceOptions;
+    }
+}
+export {};

package/dist/esm/index.d.ts

@@ -0,0 +1,20 @@
+export type { JsonResponse } from '@benjavicente/router-core/ssr/client';
+export { hydrate, json, mergeHeaders } from '@benjavicente/router-core/ssr/client';
+export { RawStream } from '@benjavicente/router-core';
+export type { OnRawStreamCallback } from '@benjavicente/router-core';
+export { createIsomorphicFn, createServerOnlyFn, createClientOnlyFn, type IsomorphicFn, type ServerOnlyFn, type ClientOnlyFn, type IsomorphicFnBase, } from '@benjavicente/start-fn-stubs';
+export { createServerFn } from './createServerFn.js';
+export { createMiddleware, type IntersectAllValidatorInputs, type IntersectAllValidatorOutputs, type FunctionMiddlewareServerFn, type AnyFunctionMiddleware, type FunctionMiddlewareOptions, type FunctionMiddlewareWithTypes, type FunctionMiddlewareValidator, type FunctionMiddlewareServer, type FunctionMiddlewareAfterClient, type FunctionMiddlewareAfterServer, type FunctionMiddleware, type FunctionMiddlewareAfterMiddleware, type FunctionMiddlewareClientFnOptions, type FunctionMiddlewareClientFnResult, type FunctionMiddlewareClientNextFn, type FunctionClientResultWithContext, type AssignAllClientContextBeforeNext, type AssignAllMiddleware, type FunctionMiddlewareAfterValidator, type FunctionMiddlewareClientFn, type FunctionMiddlewareServerFnResult, type FunctionMiddlewareClient, type FunctionMiddlewareServerFnOptions, type FunctionMiddlewareServerNextFn, type FunctionServerResultWithContext, type AnyRequestMiddleware, type RequestMiddlewareOptions, type RequestMiddlewareWithTypes, type RequestMiddlewareServer, type RequestMiddlewareAfterServer, type RequestMiddleware, type RequestMiddlewareAfterMiddleware, type RequestServerFn, type RequestMiddlewareServerFnResult, type RequestServerOptions, type RequestServerNextFn, type RequestServerNextFnOptions, type RequestServerResult, } from './createMiddleware.js';
+export type { CompiledFetcherFnOptions, CompiledFetcherFn, CustomFetch, Fetcher, RscStream, FetcherBaseOptions, ServerFn, ServerFnCtx, MiddlewareFn, ServerFnMiddlewareOptions, ServerFnMiddlewareResult, ServerFnBuilder, ServerFnBaseOptions, NextFn, Method, OptionalFetcher, RequiredFetcher, } from './createServerFn.js';
+export { execValidator, flattenMiddlewares, executeMiddleware, } from './createServerFn.js';
+export { TSS_FORMDATA_CONTEXT, TSS_SERVER_FUNCTION, TSS_CONTENT_TYPE_FRAMED, TSS_CONTENT_TYPE_FRAMED_VERSIONED, TSS_FRAMED_PROTOCOL_VERSION, FrameType, FRAME_HEADER_SIZE, X_TSS_SERIALIZED, X_TSS_RAW_RESPONSE, X_TSS_CONTEXT, validateFramedProtocolVersion, } from './constants.js';
+export type { FrameType as FrameTypeValue, ClientFnMeta, ServerFnMeta, } from './constants.js';
+export type * from './serverRoute.js';
+export type * from './startEntry.js';
+export { createStart } from './createStart.js';
+export type { AnyStartInstance, AnyStartInstanceOptions, StartInstance, StartInstanceOptions, } from './createStart.js';
+export type { Register } from '@benjavicente/router-core';
+export { getRouterInstance } from './getRouterInstance.js';
+export { getDefaultSerovalPlugins } from './getDefaultSerovalPlugins.js';
+export { getGlobalStartContext } from './getGlobalStartContext.js';
+export { safeObjectMerge, createNullProtoObject } from './safeObjectMerge.js';

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import { FRAME_HEADER_SIZE, FrameType, TSS_CONTENT_TYPE_FRAMED, TSS_CONTENT_TYPE_FRAMED_VERSIONED, TSS_FORMDATA_CONTEXT, TSS_FRAMED_PROTOCOL_VERSION, TSS_SERVER_FUNCTION, X_TSS_CONTEXT, X_TSS_RAW_RESPONSE, X_TSS_SERIALIZED, validateFramedProtocolVersion } from "./constants.js";
+import { createNullProtoObject, safeObjectMerge } from "./safeObjectMerge.js";
+import { createServerFn, execValidator, executeMiddleware, flattenMiddlewares } from "./createServerFn.js";
+import { createMiddleware } from "./createMiddleware.js";
+import { createStart } from "./createStart.js";
+import { getRouterInstance } from "./getRouterInstance.js";
+import { getDefaultSerovalPlugins } from "./getDefaultSerovalPlugins.js";
+import { getGlobalStartContext } from "./getGlobalStartContext.js";
+import { hydrate, json, mergeHeaders } from "@benjavicente/router-core/ssr/client";
+import { RawStream } from "@benjavicente/router-core";
+import { createClientOnlyFn, createIsomorphicFn, createServerOnlyFn } from "@benjavicente/start-fn-stubs";
+export { FRAME_HEADER_SIZE, FrameType, RawStream, TSS_CONTENT_TYPE_FRAMED, TSS_CONTENT_TYPE_FRAMED_VERSIONED, TSS_FORMDATA_CONTEXT, TSS_FRAMED_PROTOCOL_VERSION, TSS_SERVER_FUNCTION, X_TSS_CONTEXT, X_TSS_RAW_RESPONSE, X_TSS_SERIALIZED, createClientOnlyFn, createIsomorphicFn, createMiddleware, createNullProtoObject, createServerFn, createServerOnlyFn, createStart, execValidator, executeMiddleware, flattenMiddlewares, getDefaultSerovalPlugins, getGlobalStartContext, getRouterInstance, hydrate, json, mergeHeaders, safeObjectMerge, validateFramedProtocolVersion };

package/dist/esm/safeObjectMerge.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Merge target and source into a new null-proto object, filtering dangerous keys.
+ */
+export declare function safeObjectMerge<T extends Record<string, unknown>>(target: T | undefined, source: Record<string, unknown> | null | undefined): T;
+/**
+ * Create a null-prototype object, optionally copying from source.
+ */
+export declare function createNullProtoObject<T extends object>(source?: T): {
+    [K in keyof T]: T[K];
+};

package/dist/esm/safeObjectMerge.js

@@ -0,0 +1,30 @@
+//#region src/safeObjectMerge.ts
+function isSafeKey(key) {
+	return key !== "__proto__" && key !== "constructor" && key !== "prototype";
+}
+/**
+* Merge target and source into a new null-proto object, filtering dangerous keys.
+*/
+function safeObjectMerge(target, source) {
+	const result = Object.create(null);
+	if (target) {
+		for (const key of Object.keys(target)) if (isSafeKey(key)) result[key] = target[key];
+	}
+	if (source && typeof source === "object") {
+		for (const key of Object.keys(source)) if (isSafeKey(key)) result[key] = source[key];
+	}
+	return result;
+}
+/**
+* Create a null-prototype object, optionally copying from source.
+*/
+function createNullProtoObject(source) {
+	if (!source) return Object.create(null);
+	const obj = Object.create(null);
+	for (const key of Object.keys(source)) if (isSafeKey(key)) obj[key] = source[key];
+	return obj;
+}
+//#endregion
+export { createNullProtoObject, safeObjectMerge };
+
+//# sourceMappingURL=safeObjectMerge.js.map

package/dist/esm/safeObjectMerge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeObjectMerge.js","names":[],"sources":["../../src/safeObjectMerge.ts"],"sourcesContent":["function isSafeKey(key: string): boolean {\n  return key !== '__proto__' && key !== 'constructor' && key !== 'prototype'\n}\n\n/**\n * Merge target and source into a new null-proto object, filtering dangerous keys.\n */\nexport function safeObjectMerge<T extends Record<string, unknown>>(\n  target: T | undefined,\n  source: Record<string, unknown> | null | undefined,\n): T {\n  const result = Object.create(null) as T\n  if (target) {\n    for (const key of Object.keys(target)) {\n      if (isSafeKey(key)) result[key as keyof T] = target[key] as T[keyof T]\n    }\n  }\n  if (source && typeof source === 'object') {\n    for (const key of Object.keys(source)) {\n      if (isSafeKey(key)) result[key as keyof T] = source[key] as T[keyof T]\n    }\n  }\n  return result\n}\n\n/**\n * Create a null-prototype object, optionally copying from source.\n */\nexport function createNullProtoObject<T extends object>(\n  source?: T,\n): { [K in keyof T]: T[K] } {\n  if (!source) return Object.create(null)\n  const obj = Object.create(null)\n  for (const key of Object.keys(source)) {\n    if (isSafeKey(key)) obj[key] = (source as Record<string, unknown>)[key]\n  }\n  return obj\n}\n"],"mappings":";AAAA,SAAS,UAAU,KAAsB;AACvC,QAAO,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ;;;;;AAMjE,SAAgB,gBACd,QACA,QACG;CACH,MAAM,SAAS,OAAO,OAAO,KAAK;AAClC,KAAI;OACG,MAAM,OAAO,OAAO,KAAK,OAAO,CACnC,KAAI,UAAU,IAAI,CAAE,QAAO,OAAkB,OAAO;;AAGxD,KAAI,UAAU,OAAO,WAAW;OACzB,MAAM,OAAO,OAAO,KAAK,OAAO,CACnC,KAAI,UAAU,IAAI,CAAE,QAAO,OAAkB,OAAO;;AAGxD,QAAO;;;;;AAMT,SAAgB,sBACd,QAC0B;AAC1B,KAAI,CAAC,OAAQ,QAAO,OAAO,OAAO,KAAK;CACvC,MAAM,MAAM,OAAO,OAAO,KAAK;AAC/B,MAAK,MAAM,OAAO,OAAO,KAAK,OAAO,CACnC,KAAI,UAAU,IAAI,CAAE,KAAI,OAAQ,OAAmC;AAErE,QAAO"}

package/dist/esm/serverRoute.d.ts

@@ -0,0 +1,65 @@
+import { AnyContext, AnyRoute, Assign, Constrain, Expand, ResolveAllParamsFromParent, UnionToIntersection } from '@benjavicente/router-core';
+import { AnyRequestMiddleware, AssignAllServerRequestContext } from './createMiddleware.js';
+declare module '@benjavicente/router-core' {
+    interface FilebaseRouteOptionsInterface<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TRemountDepsFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> {
+        server?: RouteServerOptions<TRegister, TParentRoute, TPath, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>;
+    }
+    interface RouteTypes<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps, in out TLoaderFn, in out TChildren, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> {
+        middleware: TServerMiddlewares;
+        allServerContext: ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>;
+    }
+    interface BeforeLoadContextOptionsExtensions<in out TRegister, in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TRouteId, in out TServerMiddlewares, in out THandlers> {
+        serverContext?: Expand<Assign<ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>, ExtractHandlersContext<THandlers>>>;
+    }
+    interface LoaderFnContextExtensions<in out TRegister, in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TServerMiddlewares = unknown, in out THandlers = undefined> {
+        serverContext?: Expand<Assign<ResolveAllServerContext<TRegister, TParentRoute, TServerMiddlewares>, ExtractHandlersContext<THandlers>>>;
+    }
+}
+type ExtractHandlersContext<THandlers> = THandlers extends (...args: any) => CustomHandlerFunctionsRecord<any, any, any, any, any, any, infer TServerContext> ? UnionToIntersection<TServerContext> : THandlers extends Record<string, RouteMethodHandler<any, any, any, any, any, any, infer TServerContext>> ? UnionToIntersection<TServerContext> : undefined;
+export interface RouteServerOptions<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers> {
+    middleware?: Constrain<TServerMiddlewares, ReadonlyArray<AnyRequestMiddleware>>;
+    handlers?: Constrain<THandlers, Partial<Record<RouteMethod, RouteMethodHandlerFn<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, any, any>>> | ((opts: HandlersFnOpts<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares>) => CustomHandlerFunctionsRecord<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, any, any>)>;
+}
+declare const createHandlersSymbol: unique symbol;
+type CustomHandlerFunctionsRecord<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext> = {
+    [createHandlersSymbol]: true;
+} & Partial<Record<RouteMethod, RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext>>>;
+export interface HandlersFnOpts<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares> {
+    createHandlers: CreateHandlersFn<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares>;
+}
+export type CreateHandlersFn<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares> = <const TMethodAllMiddlewares, const TMethodGetMiddlewares, const TMethodPostMiddlewares, const TMethodPutMiddlewares, const TMethodPatchMiddlewares, const TMethodDeleteMiddlewares, const TMethodOptionsMiddlewares, const TMethodHeadMiddlewares, TServerContext>(opts: CreateMethodFnOpts<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodAllMiddlewares, TMethodGetMiddlewares, TMethodPostMiddlewares, TMethodPutMiddlewares, TMethodPatchMiddlewares, TMethodDeleteMiddlewares, TMethodOptionsMiddlewares, TMethodHeadMiddlewares, TServerContext>) => CustomHandlerFunctionsRecord<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, any, TServerContext>;
+export interface CreateMethodFnOpts<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares, TMethodAllMiddlewares, TMethodGetMiddlewares, TMethodPostMiddlewares, TMethodPutMiddlewares, TMethodPatchMiddlewares, TMethodDeleteMiddlewares, TMethodOptionsMiddlewares, TMethodHeadMiddlewares, TServerContext> {
+    ANY?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodAllMiddlewares, TServerContext>;
+    GET?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodGetMiddlewares, TServerContext>;
+    POST?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodPostMiddlewares, TServerContext>;
+    PUT?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodPutMiddlewares, TServerContext>;
+    PATCH?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodPatchMiddlewares, TServerContext>;
+    DELETE?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodDeleteMiddlewares, TServerContext>;
+    OPTIONS?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodOptionsMiddlewares, TServerContext>;
+    HEAD?: RouteMethodHandler<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodHeadMiddlewares, TServerContext>;
+}
+export type RouteMethodHandler<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext> = RouteMethodHandlerFn<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext> | RouteMethodBuilderOptions<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext>;
+export interface RouteMethodBuilderOptions<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares, TMethodMiddlewares, TResponse> {
+    handler?: RouteMethodHandlerFn<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodMiddlewares, TResponse>;
+    middleware?: Constrain<TMethodMiddlewares, ReadonlyArray<AnyRequestMiddleware>>;
+}
+export type ResolveAllServerContext<TRegister, TParentRoute extends AnyRoute, TServerMiddlewares> = unknown extends TParentRoute ? AssignAllServerRequestContext<TRegister, TServerMiddlewares, {}> : Assign<TParentRoute['types']['allServerContext'], AssignAllServerRequestContext<TRegister, TServerMiddlewares, {}>>;
+export type RouteMethod = 'ANY' | 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+export type RouteMethodHandlerFn<TRegister, TParentRoute extends AnyRoute, TFullPath extends string, TParams, TServerMiddlewares, TMethodMiddlewares, TServerContext> = (ctx: RouteMethodHandlerCtx<TRegister, TParentRoute, TFullPath, TParams, TServerMiddlewares, TMethodMiddlewares>) => RouteMethodResult<TServerContext> | Promise<RouteMethodResult<TServerContext>>;
+export type RouteMethodResult<TContext> = Response | undefined | RouteMethodNextResult<TContext>;
+export type RouteMethodNextResult<TContext> = {
+    isNext: true;
+    context: TContext;
+};
+export interface RouteMethodHandlerCtx<in out TRegister, in out TParentRoute extends AnyRoute, in out TFullPath extends string, in out TParams, in out TServerMiddlewares, in out TMethodMiddlewares> {
+    context: Expand<AssignAllMethodContext<TRegister, TParentRoute, TServerMiddlewares, TMethodMiddlewares>>;
+    request: Request;
+    params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
+    pathname: TFullPath;
+    next: <TContext = undefined>(options?: {
+        context?: TContext;
+    }) => RouteMethodNextResult<TContext>;
+}
+export type MergeMethodMiddlewares<TServerMiddlewares, TMethodMiddlewares> = TServerMiddlewares extends ReadonlyArray<any> ? TMethodMiddlewares extends ReadonlyArray<any> ? readonly [...TServerMiddlewares, ...TMethodMiddlewares] : TServerMiddlewares : TMethodMiddlewares;
+export type AssignAllMethodContext<TRegister, TParentRoute extends AnyRoute, TServerMiddlewares, TMethodMiddlewares> = ResolveAllServerContext<TRegister, TParentRoute, MergeMethodMiddlewares<TServerMiddlewares, TMethodMiddlewares>>;
+export {};

package/dist/esm/startEntry.d.ts

@@ -0,0 +1,8 @@
+import { AnyRouter, Awaitable } from '@benjavicente/router-core';
+import { AnyStartInstance } from './createStart.js';
+export interface StartEntry {
+    startInstance: AnyStartInstance | undefined;
+}
+export interface RouterEntry {
+    getRouter: () => Awaitable<AnyRouter>;
+}

package/dist/esm/tests/createServerFn.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/tests/createServerMiddleware.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@benjavicente/start-client-core",
+  "version": "1.167.9",
+  "description": "Modern and scalable routing for React applications",
+  "author": "Tanner Linsley",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TanStack/router.git",
+    "directory": "packages/start-client-core"
+  },
+  "homepage": "https://tanstack.com/start",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tannerlinsley"
+  },
+  "keywords": [
+    "react",
+    "location",
+    "router",
+    "routing",
+    "async",
+    "async router",
+    "typescript"
+  ],
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    },
+    "./client": {
+      "import": {
+        "types": "./dist/esm/client/index.d.ts",
+        "default": "./dist/esm/client/index.js"
+      }
+    },
+    "./client-rpc": {
+      "import": {
+        "types": "./dist/esm/client-rpc/index.d.ts",
+        "default": "./dist/esm/client-rpc/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "imports": {
+    "#tanstack-start-entry": {
+      "default": "./dist/esm/fake-start-entry.js"
+    },
+    "#tanstack-router-entry": {
+      "default": "./dist/esm/fake-start-entry.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "skills",
+    "bin",
+    "!skills/_artifacts"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "seroval": "^1.4.2",
+    "@benjavicente/router-core": "1.168.9",
+    "@benjavicente/start-fn-stubs": "1.161.6",
+    "@benjavicente/start-storage-context": "1.166.23"
+  },
+  "devDependencies": {
+    "@tanstack/intent": "^0.0.14",
+    "vite": "*",
+    "@types/node": ">=20"
+  },
+  "bin": {
+    "intent": "./bin/intent.js"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist && rimraf ./coverage",
+    "test": "pnpm test:eslint && pnpm test:types && pnpm test:build && pnpm test:unit",
+    "test:unit": "vitest",
+    "test:unit:dev": "vitest --watch",
+    "test:eslint": "eslint ./src",
+    "test:types": "pnpm run \"/^test:types:ts[0-9]{2}$/\"",
+    "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js",
+    "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js",
+    "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js",
+    "test:types:ts58": "node ../../node_modules/typescript58/lib/tsc.js",
+    "test:types:ts59": "node ../../node_modules/typescript59/lib/tsc.js",
+    "test:types:ts60": "tsc",
+    "test:build": "publint --strict && attw --ignore-rules no-resolution --pack .",
+    "build": "vite build"
+  }
+}

package/skills/start-core/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: start-core
+description: >-
+  Core overview for TanStack Start: tanstackStart() Vite plugin,
+  getRouter() factory, root route document shell (HeadContent,
+  Scripts, Outlet), client/server entry points, routeTree.gen.ts,
+  tsconfig configuration. Entry point for all Start skills.
+type: core
+library: tanstack-start
+library_version: '1.166.2'
+sources:
+  - TanStack/router:docs/start/framework/react/build-from-scratch.md
+  - TanStack/router:docs/start/framework/react/quick-start.md
+  - TanStack/router:docs/start/framework/react/guide/routing.md
+---
+
+# TanStack Start Core
+
+TanStack Start is a full-stack React framework built on TanStack Router and Vite. It adds SSR, streaming, server functions (type-safe RPCs), middleware, server routes, and universal deployment.
+
+> **CRITICAL**: All code in TanStack Start is ISOMORPHIC by default — it runs in BOTH server and client environments. Loaders run on both server AND client. To run code exclusively on the server, use `createServerFn`. This is the #1 AI agent mistake.
+> **CRITICAL**: TanStack Start is NOT Next.js. Do not generate `getServerSideProps`, `"use server"` directives, `app/layout.tsx`, or any Next.js/Remix patterns. Use `createServerFn` for server-only code.
+> **CRITICAL**: Types are FULLY INFERRED. Never cast, never annotate inferred values.
+
+## Sub-Skills
+
+| Task                                         | Sub-Skill                                                           |
+| -------------------------------------------- | ------------------------------------------------------------------- |
+| Type-safe RPCs, data fetching, mutations     | [start-core/server-functions/SKILL.md](./server-functions/SKILL.md) |
+| Request/function middleware, context, auth   | [start-core/middleware/SKILL.md](./middleware/SKILL.md)             |
+| Isomorphic execution, environment boundaries | [start-core/execution-model/SKILL.md](./execution-model/SKILL.md)   |
+| REST API endpoints alongside app routes      | [start-core/server-routes/SKILL.md](./server-routes/SKILL.md)       |
+| Hosting, SSR modes, prerendering, SEO        | [start-core/deployment/SKILL.md](./deployment/SKILL.md)             |
+
+## Quick Decision Tree
+
+```text
+Need to run code exclusively on the server (DB, secrets)?
+  → start-core/server-functions
+
+Need auth checks, logging, or shared logic across server functions?
+  → start-core/middleware
+
+Need to understand where code runs (server vs client)?
+  → start-core/execution-model
+
+Need a REST API endpoint (GET/POST/PUT/DELETE)?
+  → start-core/server-routes
+
+Need to deploy, configure SSR, or prerender?
+  → start-core/deployment
+```
+
+## Project Setup
+
+### 1. Install Dependencies
+
+```bash
+npm i @benjavicente/react-start @benjavicente/react-router react react-dom
+npm i -D vite @vitejs/plugin-react typescript
+```
+
+### 2. Configure Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite'
+import { tanstackStart } from '@benjavicente/react-start/plugin/vite'
+import viteReact from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [
+    // MUST come before react()
+    tanstackStart(),
+    viteReact(),
+  ],
+})
+```
+
+### 3. Create Router Factory
+
+```tsx
+// src/router.tsx
+import { createRouter } from '@benjavicente/react-router'
+import { routeTree } from './routeTree.gen'
+
+export function getRouter() {
+  const router = createRouter({
+    routeTree,
+    scrollRestoration: true,
+  })
+
+  return router
+}
+```
+
+### 4. Create Root Route with Document Shell
+
+```tsx
+// src/routes/__root.tsx
+import type { ReactNode } from 'react'
+import {
+  Outlet,
+  createRootRoute,
+  HeadContent,
+  Scripts,
+} from '@benjavicente/react-router'
+
+export const Route = createRootRoute({
+  head: () => ({
+    meta: [
+      { charSet: 'utf-8' },
+      { name: 'viewport', content: 'width=device-width, initial-scale=1' },
+      { title: 'My App' },
+    ],
+  }),
+  component: RootComponent,
+})
+
+function RootComponent() {
+  return (
+    <html>
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <Outlet />
+        <Scripts />
+      </body>
+    </html>
+  )
+}
+```
+
+### 5. Create Index Route with Server Function
+
+```tsx
+// src/routes/index.tsx
+import { createFileRoute } from '@benjavicente/react-router'
+import { createServerFn } from '@benjavicente/react-start'
+
+const getGreeting = createServerFn({ method: 'GET' }).handler(async () => {
+  return { message: 'Hello from the server!' }
+})
+
+export const Route = createFileRoute('/')({
+  loader: () => getGreeting(),
+  component: HomePage,
+})
+
+function HomePage() {
+  const data = Route.useLoaderData()
+  return <h1>{data.message}</h1>
+}
+```
+
+## Common Mistakes
+
+### 1. CRITICAL: React plugin before Start plugin in Vite config
+
+```ts
+// WRONG — route generation and server function compilation fail
+plugins: [react(), tanstackStart()]
+
+// CORRECT — Start plugin must come first
+plugins: [tanstackStart(), react()]
+```
+
+### 2. HIGH: Enabling verbatimModuleSyntax in tsconfig
+
+`verbatimModuleSyntax` causes server bundles to leak into client bundles. Keep it disabled.
+
+### 3. HIGH: Missing Scripts component in root route
+
+The `<Scripts />` component must be rendered in the `<body>` of the root route. Without it, client-side JavaScript does not load and hydration fails.
+
+```tsx
+// WRONG — no Scripts
+function RootComponent() {
+  return (
+    <html>
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <Outlet />
+      </body>
+    </html>
+  )
+}
+
+// CORRECT — Scripts in body
+function RootComponent() {
+  return (
+    <html>
+      <head>
+        <HeadContent />
+      </head>
+      <body>
+        <Outlet />
+        <Scripts />
+      </body>
+    </html>
+  )
+}
+```
+
+## Version Note
+
+This skill targets `@benjavicente/react-start` v1.166.2 and `@benjavicente/start-client-core` v1.166.2.