@benjavicente/start-client-core 1.167.9

package/dist/esm/client-rpc/serverFnFetcher.js

@@ -0,0 +1,231 @@
+import { TSS_CONTENT_TYPE_FRAMED, TSS_FORMDATA_CONTEXT, validateFramedProtocolVersion } from "../constants.js";
+import { getDefaultSerovalPlugins } from "../getDefaultSerovalPlugins.js";
+import { createFrameDecoder } from "./frame-decoder.js";
+import { createRawStreamDeserializePlugin, encode, invariant, isNotFound, parseRedirect } from "@benjavicente/router-core";
+import { fromCrossJSON, toJSONAsync } from "seroval";
+//#region src/client-rpc/serverFnFetcher.ts
+var serovalPlugins = null;
+/**
+* Checks if an object has at least one own enumerable property.
+* More efficient than Object.keys(obj).length > 0 as it short-circuits on first property.
+*/
+var hop = Object.prototype.hasOwnProperty;
+function hasOwnProperties(obj) {
+	for (const _ in obj) if (hop.call(obj, _)) return true;
+	return false;
+}
+async function serverFnFetcher(url, args, handler) {
+	if (!serovalPlugins) serovalPlugins = getDefaultSerovalPlugins();
+	const first = args[0];
+	const fetchImpl = first.fetch ?? handler;
+	const type = first.data instanceof FormData ? "formData" : "payload";
+	const headers = first.headers ? new Headers(first.headers) : new Headers();
+	headers.set("x-tsr-serverFn", "true");
+	if (type === "payload") headers.set("accept", `${TSS_CONTENT_TYPE_FRAMED}, application/x-ndjson, application/json`);
+	if (first.method === "GET") {
+		if (type === "formData") throw new Error("FormData is not supported with GET requests");
+		const serializedPayload = await serializePayload(first);
+		if (serializedPayload !== void 0) {
+			const encodedPayload = encode({ payload: serializedPayload });
+			if (url.includes("?")) url += `&${encodedPayload}`;
+			else url += `?${encodedPayload}`;
+		}
+	}
+	let body = void 0;
+	if (first.method === "POST") {
+		const fetchBody = await getFetchBody(first);
+		if (fetchBody?.contentType) headers.set("content-type", fetchBody.contentType);
+		body = fetchBody?.body;
+	}
+	return await getResponse(async () => fetchImpl(url, {
+		method: first.method,
+		headers,
+		signal: first.signal,
+		body
+	}));
+}
+async function serializePayload(opts) {
+	let payloadAvailable = false;
+	const payloadToSerialize = {};
+	if (opts.data !== void 0) {
+		payloadAvailable = true;
+		payloadToSerialize["data"] = opts.data;
+	}
+	if (opts.context && hasOwnProperties(opts.context)) {
+		payloadAvailable = true;
+		payloadToSerialize["context"] = opts.context;
+	}
+	if (payloadAvailable) return serialize(payloadToSerialize);
+}
+async function serialize(data) {
+	return JSON.stringify(await Promise.resolve(toJSONAsync(data, { plugins: serovalPlugins })));
+}
+async function getFetchBody(opts) {
+	if (opts.data instanceof FormData) {
+		let serializedContext = void 0;
+		if (opts.context && hasOwnProperties(opts.context)) serializedContext = await serialize(opts.context);
+		if (serializedContext !== void 0) opts.data.set(TSS_FORMDATA_CONTEXT, serializedContext);
+		return { body: opts.data };
+	}
+	const serializedBody = await serializePayload(opts);
+	if (serializedBody) return {
+		body: serializedBody,
+		contentType: "application/json"
+	};
+}
+/**
+* Retrieves a response from a given function and manages potential errors
+* and special response types including redirects and not found errors.
+*
+* @param fn - The function to execute for obtaining the response.
+* @returns The processed response from the function.
+* @throws If the response is invalid or an error occurs during processing.
+*/
+async function getResponse(fn) {
+	let response;
+	try {
+		response = await fn();
+	} catch (error) {
+		if (error instanceof Response) response = error;
+		else {
+			console.log(error);
+			throw error;
+		}
+	}
+	if (response.headers.get("x-tss-raw") === "true") return response;
+	const contentType = response.headers.get("content-type");
+	if (!contentType) {
+		if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: expected content-type header to be set");
+		invariant();
+	}
+	if (!!response.headers.get("x-tss-serialized")) {
+		let result;
+		if (contentType.includes("application/x-tss-framed")) {
+			validateFramedProtocolVersion(contentType);
+			if (!response.body) throw new Error("No response body for framed response");
+			const { getOrCreateStream, jsonChunks } = createFrameDecoder(response.body);
+			const plugins = [createRawStreamDeserializePlugin(getOrCreateStream), ...serovalPlugins || []];
+			const refs = /* @__PURE__ */ new Map();
+			result = await processFramedResponse({
+				jsonStream: jsonChunks,
+				onMessage: (msg) => fromCrossJSON(msg, {
+					refs,
+					plugins
+				}),
+				onError(msg, error) {
+					console.error(msg, error);
+				}
+			});
+		} else if (contentType.includes("application/x-ndjson")) {
+			const refs = /* @__PURE__ */ new Map();
+			result = await processServerFnResponse({
+				response,
+				onMessage: (msg) => fromCrossJSON(msg, {
+					refs,
+					plugins: serovalPlugins
+				}),
+				onError(msg, error) {
+					console.error(msg, error);
+				}
+			});
+		} else if (contentType.includes("application/json")) result = fromCrossJSON(await response.json(), { plugins: serovalPlugins });
+		if (!result) {
+			if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: expected result to be resolved");
+			invariant();
+		}
+		if (result instanceof Error) throw result;
+		return result;
+	}
+	if (contentType.includes("application/json")) {
+		const jsonPayload = await response.json();
+		const redirect = parseRedirect(jsonPayload);
+		if (redirect) throw redirect;
+		if (isNotFound(jsonPayload)) throw jsonPayload;
+		return jsonPayload;
+	}
+	if (!response.ok) throw new Error(await response.text());
+	return response;
+}
+async function processServerFnResponse({ response, onMessage, onError }) {
+	if (!response.body) throw new Error("No response body");
+	const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+	let buffer = "";
+	let firstRead = false;
+	let firstObject;
+	while (!firstRead) {
+		const { value, done } = await reader.read();
+		if (value) buffer += value;
+		if (buffer.length === 0 && done) throw new Error("Stream ended before first object");
+		if (buffer.endsWith("\n")) {
+			const lines = buffer.split("\n").filter(Boolean);
+			const firstLine = lines[0];
+			if (!firstLine) throw new Error("No JSON line in the first chunk");
+			firstObject = JSON.parse(firstLine);
+			firstRead = true;
+			buffer = lines.slice(1).join("\n");
+		} else {
+			const newlineIndex = buffer.indexOf("\n");
+			if (newlineIndex >= 0) {
+				const line = buffer.slice(0, newlineIndex).trim();
+				buffer = buffer.slice(newlineIndex + 1);
+				if (line.length > 0) {
+					firstObject = JSON.parse(line);
+					firstRead = true;
+				}
+			}
+		}
+	}
+	(async () => {
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (value) buffer += value;
+				const lastNewline = buffer.lastIndexOf("\n");
+				if (lastNewline >= 0) {
+					const chunk = buffer.slice(0, lastNewline);
+					buffer = buffer.slice(lastNewline + 1);
+					const lines = chunk.split("\n").filter(Boolean);
+					for (const line of lines) try {
+						onMessage(JSON.parse(line));
+					} catch (e) {
+						onError?.(`Invalid JSON line: ${line}`, e);
+					}
+				}
+				if (done) break;
+			}
+		} catch (err) {
+			onError?.("Stream processing error:", err);
+		}
+	})();
+	return onMessage(firstObject);
+}
+/**
+* Processes a framed response where each JSON chunk is a complete JSON string
+* (already decoded by frame decoder).
+*/
+async function processFramedResponse({ jsonStream, onMessage, onError }) {
+	const reader = jsonStream.getReader();
+	const { value: firstValue, done: firstDone } = await reader.read();
+	if (firstDone || !firstValue) throw new Error("Stream ended before first object");
+	const firstObject = JSON.parse(firstValue);
+	(async () => {
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				if (value) try {
+					onMessage(JSON.parse(value));
+				} catch (e) {
+					onError?.(`Invalid JSON: ${value}`, e);
+				}
+			}
+		} catch (err) {
+			onError?.("Stream processing error:", err);
+		}
+	})();
+	return onMessage(firstObject);
+}
+//#endregion
+export { serverFnFetcher };
+
+//# sourceMappingURL=serverFnFetcher.js.map

package/dist/esm/client-rpc/serverFnFetcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverFnFetcher.js","names":[],"sources":["../../../src/client-rpc/serverFnFetcher.ts"],"sourcesContent":["import {\n  createRawStreamDeserializePlugin,\n  encode,\n  invariant,\n  isNotFound,\n  parseRedirect,\n} from '@benjavicente/router-core'\nimport { fromCrossJSON, toJSONAsync } from 'seroval'\nimport { getDefaultSerovalPlugins } from '../getDefaultSerovalPlugins'\nimport {\n  TSS_CONTENT_TYPE_FRAMED,\n  TSS_FORMDATA_CONTEXT,\n  X_TSS_RAW_RESPONSE,\n  X_TSS_SERIALIZED,\n  validateFramedProtocolVersion,\n} from '../constants'\nimport { createFrameDecoder } from './frame-decoder'\nimport type { FunctionMiddlewareClientFnOptions } from '../createMiddleware'\nimport type { Plugin as SerovalPlugin } from 'seroval'\n\nlet serovalPlugins: Array<SerovalPlugin<any, any>> | null = null\n\n/**\n * Checks if an object has at least one own enumerable property.\n * More efficient than Object.keys(obj).length > 0 as it short-circuits on first property.\n */\nconst hop = Object.prototype.hasOwnProperty\nfunction hasOwnProperties(obj: object): boolean {\n  for (const _ in obj) {\n    if (hop.call(obj, _)) {\n      return true\n    }\n  }\n  return false\n}\n// caller =>\n//   serverFnFetcher =>\n//     client =>\n//       server =>\n//         fn =>\n//       seroval =>\n//     client middleware =>\n//   serverFnFetcher =>\n// caller\n\nexport async function serverFnFetcher(\n  url: string,\n  args: Array<any>,\n  handler: (url: string, requestInit: RequestInit) => Promise<Response>,\n) {\n  if (!serovalPlugins) {\n    serovalPlugins = getDefaultSerovalPlugins()\n  }\n  const _first = args[0]\n\n  const first = _first as FunctionMiddlewareClientFnOptions<any, any, any> & {\n    headers?: HeadersInit\n  }\n\n  // Use custom fetch if provided, otherwise fall back to the passed handler (global fetch)\n  const fetchImpl = first.fetch ?? handler\n\n  const type = first.data instanceof FormData ? 'formData' : 'payload'\n\n  // Arrange the headers\n  const headers = first.headers ? new Headers(first.headers) : new Headers()\n  headers.set('x-tsr-serverFn', 'true')\n\n  if (type === 'payload') {\n    headers.set(\n      'accept',\n      `${TSS_CONTENT_TYPE_FRAMED}, application/x-ndjson, application/json`,\n    )\n  }\n\n  // If the method is GET, we need to move the payload to the query string\n  if (first.method === 'GET') {\n    if (type === 'formData') {\n      throw new Error('FormData is not supported with GET requests')\n    }\n    const serializedPayload = await serializePayload(first)\n    if (serializedPayload !== undefined) {\n      const encodedPayload = encode({\n        payload: serializedPayload,\n      })\n      if (url.includes('?')) {\n        url += `&${encodedPayload}`\n      } else {\n        url += `?${encodedPayload}`\n      }\n    }\n  }\n\n  let body = undefined\n  if (first.method === 'POST') {\n    const fetchBody = await getFetchBody(first)\n    if (fetchBody?.contentType) {\n      headers.set('content-type', fetchBody.contentType)\n    }\n    body = fetchBody?.body\n  }\n\n  return await getResponse(async () =>\n    fetchImpl(url, {\n      method: first.method,\n      headers,\n      signal: first.signal,\n      body,\n    }),\n  )\n}\n\nasync function serializePayload(\n  opts: FunctionMiddlewareClientFnOptions<any, any, any>,\n): Promise<string | undefined> {\n  let payloadAvailable = false\n  const payloadToSerialize: any = {}\n  if (opts.data !== undefined) {\n    payloadAvailable = true\n    payloadToSerialize['data'] = opts.data\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  if (opts.context && hasOwnProperties(opts.context)) {\n    payloadAvailable = true\n    payloadToSerialize['context'] = opts.context\n  }\n\n  if (payloadAvailable) {\n    return serialize(payloadToSerialize)\n  }\n  return undefined\n}\n\nasync function serialize(data: any) {\n  return JSON.stringify(\n    await Promise.resolve(toJSONAsync(data, { plugins: serovalPlugins! })),\n  )\n}\n\nasync function getFetchBody(\n  opts: FunctionMiddlewareClientFnOptions<any, any, any>,\n): Promise<{ body: FormData | string; contentType?: string } | undefined> {\n  if (opts.data instanceof FormData) {\n    let serializedContext = undefined\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    if (opts.context && hasOwnProperties(opts.context)) {\n      serializedContext = await serialize(opts.context)\n    }\n    if (serializedContext !== undefined) {\n      opts.data.set(TSS_FORMDATA_CONTEXT, serializedContext)\n    }\n    return { body: opts.data }\n  }\n  const serializedBody = await serializePayload(opts)\n  if (serializedBody) {\n    return { body: serializedBody, contentType: 'application/json' }\n  }\n  return undefined\n}\n\n/**\n * Retrieves a response from a given function and manages potential errors\n * and special response types including redirects and not found errors.\n *\n * @param fn - The function to execute for obtaining the response.\n * @returns The processed response from the function.\n * @throws If the response is invalid or an error occurs during processing.\n */\nasync function getResponse(fn: () => Promise<Response>) {\n  let response: Response\n  try {\n    response = await fn() // client => server => fn => server => client\n  } catch (error) {\n    if (error instanceof Response) {\n      response = error\n    } else {\n      console.log(error)\n      throw error\n    }\n  }\n\n  if (response.headers.get(X_TSS_RAW_RESPONSE) === 'true') {\n    return response\n  }\n\n  const contentType = response.headers.get('content-type')\n  if (!contentType) {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error(\n        'Invariant failed: expected content-type header to be set',\n      )\n    }\n\n    invariant()\n  }\n  const serializedByStart = !!response.headers.get(X_TSS_SERIALIZED)\n\n  // If the response is serialized by the start server, we need to process it\n  // differently than a normal response.\n  if (serializedByStart) {\n    let result\n\n    // If it's a framed response (contains RawStream), use frame decoder\n    if (contentType.includes(TSS_CONTENT_TYPE_FRAMED)) {\n      // Validate protocol version compatibility\n      validateFramedProtocolVersion(contentType)\n\n      if (!response.body) {\n        throw new Error('No response body for framed response')\n      }\n\n      const { getOrCreateStream, jsonChunks } = createFrameDecoder(\n        response.body,\n      )\n\n      // Create deserialize plugin that wires up the raw streams\n      const rawStreamPlugin =\n        createRawStreamDeserializePlugin(getOrCreateStream)\n      const plugins = [rawStreamPlugin, ...(serovalPlugins || [])]\n\n      const refs = new Map()\n      result = await processFramedResponse({\n        jsonStream: jsonChunks,\n        onMessage: (msg: any) => fromCrossJSON(msg, { refs, plugins }),\n        onError(msg, error) {\n          console.error(msg, error)\n        },\n      })\n    }\n    // If it's a stream from the start serializer, process it as such\n    else if (contentType.includes('application/x-ndjson')) {\n      const refs = new Map()\n      result = await processServerFnResponse({\n        response,\n        onMessage: (msg) =>\n          fromCrossJSON(msg, { refs, plugins: serovalPlugins! }),\n        onError(msg, error) {\n          // TODO how could we notify consumer that an error occurred?\n          console.error(msg, error)\n        },\n      })\n    }\n    // If it's a JSON response, it can be simpler\n    else if (contentType.includes('application/json')) {\n      const jsonPayload = await response.json()\n      result = fromCrossJSON(jsonPayload, { plugins: serovalPlugins! })\n    }\n\n    if (!result) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error('Invariant failed: expected result to be resolved')\n      }\n\n      invariant()\n    }\n    if (result instanceof Error) {\n      throw result\n    }\n\n    return result\n  }\n\n  // If it wasn't processed by the start serializer, check\n  // if it's JSON\n  if (contentType.includes('application/json')) {\n    const jsonPayload = await response.json()\n    const redirect = parseRedirect(jsonPayload)\n    if (redirect) {\n      throw redirect\n    }\n    if (isNotFound(jsonPayload)) {\n      throw jsonPayload\n    }\n    return jsonPayload\n  }\n\n  // Otherwise, if it's not OK, throw the content\n  if (!response.ok) {\n    throw new Error(await response.text())\n  }\n\n  // Or return the response itself\n  return response\n}\n\nasync function processServerFnResponse({\n  response,\n  onMessage,\n  onError,\n}: {\n  response: Response\n  onMessage: (msg: any) => any\n  onError?: (msg: string, error?: any) => void\n}) {\n  if (!response.body) {\n    throw new Error('No response body')\n  }\n\n  const reader = response.body.pipeThrough(new TextDecoderStream()).getReader()\n\n  let buffer = ''\n  let firstRead = false\n  let firstObject\n\n  while (!firstRead) {\n    const { value, done } = await reader.read()\n    if (value) buffer += value\n\n    if (buffer.length === 0 && done) {\n      throw new Error('Stream ended before first object')\n    }\n\n    // common case: buffer ends with newline\n    if (buffer.endsWith('\\n')) {\n      const lines = buffer.split('\\n').filter(Boolean)\n      const firstLine = lines[0]\n      if (!firstLine) throw new Error('No JSON line in the first chunk')\n      firstObject = JSON.parse(firstLine)\n      firstRead = true\n      buffer = lines.slice(1).join('\\n')\n    } else {\n      // fallback: wait for a newline to parse first object safely\n      const newlineIndex = buffer.indexOf('\\n')\n      if (newlineIndex >= 0) {\n        const line = buffer.slice(0, newlineIndex).trim()\n        buffer = buffer.slice(newlineIndex + 1)\n        if (line.length > 0) {\n          firstObject = JSON.parse(line)\n          firstRead = true\n        }\n      }\n    }\n  }\n\n  // process rest of the stream asynchronously\n  ;(async () => {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      while (true) {\n        const { value, done } = await reader.read()\n        if (value) buffer += value\n\n        const lastNewline = buffer.lastIndexOf('\\n')\n        if (lastNewline >= 0) {\n          const chunk = buffer.slice(0, lastNewline)\n          buffer = buffer.slice(lastNewline + 1)\n          const lines = chunk.split('\\n').filter(Boolean)\n\n          for (const line of lines) {\n            try {\n              onMessage(JSON.parse(line))\n            } catch (e) {\n              onError?.(`Invalid JSON line: ${line}`, e)\n            }\n          }\n        }\n\n        if (done) {\n          break\n        }\n      }\n    } catch (err) {\n      onError?.('Stream processing error:', err)\n    }\n  })()\n\n  return onMessage(firstObject)\n}\n\n/**\n * Processes a framed response where each JSON chunk is a complete JSON string\n * (already decoded by frame decoder).\n */\nasync function processFramedResponse({\n  jsonStream,\n  onMessage,\n  onError,\n}: {\n  jsonStream: ReadableStream<string>\n  onMessage: (msg: any) => any\n  onError?: (msg: string, error?: any) => void\n}) {\n  const reader = jsonStream.getReader()\n\n  // Read first JSON frame - this is the main result\n  const { value: firstValue, done: firstDone } = await reader.read()\n  if (firstDone || !firstValue) {\n    throw new Error('Stream ended before first object')\n  }\n\n  // Each frame is a complete JSON string\n  const firstObject = JSON.parse(firstValue)\n\n  // Process remaining frames asynchronously (for streaming refs like RawStream)\n  ;(async () => {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n      while (true) {\n        const { value, done } = await reader.read()\n        if (done) break\n        if (value) {\n          try {\n            onMessage(JSON.parse(value))\n          } catch (e) {\n            onError?.(`Invalid JSON: ${value}`, e)\n          }\n        }\n      }\n    } catch (err) {\n      onError?.('Stream processing error:', err)\n    }\n  })()\n\n  return onMessage(firstObject)\n}\n"],"mappings":"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"}

package/dist/esm/constants.d.ts

@@ -0,0 +1,53 @@
+export declare const TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+export declare const TSS_SERVER_FUNCTION: unique symbol;
+export declare const TSS_SERVER_FUNCTION_FACTORY: unique symbol;
+export declare const X_TSS_SERIALIZED = "x-tss-serialized";
+export declare const X_TSS_RAW_RESPONSE = "x-tss-raw";
+export declare const X_TSS_CONTEXT = "x-tss-context";
+/** Content-Type for multiplexed framed responses (RawStream support) */
+export declare const TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+/**
+ * Frame types for binary multiplexing protocol.
+ */
+export declare const FrameType: {
+    /** Seroval JSON chunk (NDJSON line) */
+    readonly JSON: 0;
+    /** Raw stream data chunk */
+    readonly CHUNK: 1;
+    /** Raw stream end (EOF) */
+    readonly END: 2;
+    /** Raw stream error */
+    readonly ERROR: 3;
+};
+export type FrameType = (typeof FrameType)[keyof typeof FrameType];
+/** Header size in bytes: type(1) + streamId(4) + length(4) */
+export declare const FRAME_HEADER_SIZE = 9;
+/** Current protocol version for framed responses */
+export declare const TSS_FRAMED_PROTOCOL_VERSION = 1;
+/** Full Content-Type header value with version parameter */
+export declare const TSS_CONTENT_TYPE_FRAMED_VERSIONED = "application/x-tss-framed; v=1";
+export declare function parseFramedProtocolVersion(contentType: string): number | undefined;
+/**
+ * Validates that the server's protocol version is compatible with this client.
+ * Throws an error if versions are incompatible.
+ */
+export declare function validateFramedProtocolVersion(contentType: string): void;
+/**
+ * Minimal metadata about a server function, available to client middleware.
+ * Only contains the function ID since name/filename may expose server internals.
+ */
+export interface ClientFnMeta {
+    /** The unique identifier for this server function */
+    id: string;
+}
+/**
+ * Full metadata about a server function, available to server middleware and server functions.
+ * This information is embedded at compile time by the TanStack Start compiler.
+ */
+export interface ServerFnMeta extends ClientFnMeta {
+    /** The original variable name of the server function (e.g., "myServerFn") */
+    name: string;
+    /** The source file path relative to the project root (e.g., "src/routes/api.ts") */
+    filename: string;
+}
+export {};

package/dist/esm/constants.js

@@ -0,0 +1,46 @@
+//#region src/constants.ts
+var TSS_FORMDATA_CONTEXT = "__TSS_CONTEXT";
+var TSS_SERVER_FUNCTION = Symbol.for("TSS_SERVER_FUNCTION");
+var TSS_SERVER_FUNCTION_FACTORY = Symbol.for("TSS_SERVER_FUNCTION_FACTORY");
+var X_TSS_SERIALIZED = "x-tss-serialized";
+var X_TSS_RAW_RESPONSE = "x-tss-raw";
+var X_TSS_CONTEXT = "x-tss-context";
+/** Content-Type for multiplexed framed responses (RawStream support) */
+var TSS_CONTENT_TYPE_FRAMED = "application/x-tss-framed";
+/**
+* Frame types for binary multiplexing protocol.
+*/
+var FrameType = {
+	JSON: 0,
+	CHUNK: 1,
+	END: 2,
+	ERROR: 3
+};
+/** Header size in bytes: type(1) + streamId(4) + length(4) */
+var FRAME_HEADER_SIZE = 9;
+/** Current protocol version for framed responses */
+var TSS_FRAMED_PROTOCOL_VERSION = 1;
+/** Full Content-Type header value with version parameter */
+var TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=1`;
+/**
+* Parses the version parameter from a framed Content-Type header.
+* Returns undefined if no version parameter is present.
+*/
+var FRAMED_VERSION_REGEX = /;\s*v=(\d+)/;
+function parseFramedProtocolVersion(contentType) {
+	const match = contentType.match(FRAMED_VERSION_REGEX);
+	return match ? parseInt(match[1], 10) : void 0;
+}
+/**
+* Validates that the server's protocol version is compatible with this client.
+* Throws an error if versions are incompatible.
+*/
+function validateFramedProtocolVersion(contentType) {
+	const serverVersion = parseFramedProtocolVersion(contentType);
+	if (serverVersion === void 0) return;
+	if (serverVersion !== 1) throw new Error(`Incompatible framed protocol version: server=${serverVersion}, client=1. Please ensure client and server are using compatible versions.`);
+}
+//#endregion
+export { FRAME_HEADER_SIZE, FrameType, TSS_CONTENT_TYPE_FRAMED, TSS_CONTENT_TYPE_FRAMED_VERSIONED, TSS_FORMDATA_CONTEXT, TSS_FRAMED_PROTOCOL_VERSION, TSS_SERVER_FUNCTION, TSS_SERVER_FUNCTION_FACTORY, X_TSS_CONTEXT, X_TSS_RAW_RESPONSE, X_TSS_SERIALIZED, validateFramedProtocolVersion };
+
+//# sourceMappingURL=constants.js.map

package/dist/esm/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/constants.ts"],"sourcesContent":["export const TSS_FORMDATA_CONTEXT = '__TSS_CONTEXT'\nexport const TSS_SERVER_FUNCTION = Symbol.for('TSS_SERVER_FUNCTION')\nexport const TSS_SERVER_FUNCTION_FACTORY = Symbol.for(\n  'TSS_SERVER_FUNCTION_FACTORY',\n)\n\nexport const X_TSS_SERIALIZED = 'x-tss-serialized'\nexport const X_TSS_RAW_RESPONSE = 'x-tss-raw'\nexport const X_TSS_CONTEXT = 'x-tss-context'\n\n/** Content-Type for multiplexed framed responses (RawStream support) */\nexport const TSS_CONTENT_TYPE_FRAMED = 'application/x-tss-framed'\n\n/**\n * Frame types for binary multiplexing protocol.\n */\nexport const FrameType = {\n  /** Seroval JSON chunk (NDJSON line) */\n  JSON: 0,\n  /** Raw stream data chunk */\n  CHUNK: 1,\n  /** Raw stream end (EOF) */\n  END: 2,\n  /** Raw stream error */\n  ERROR: 3,\n} as const\n\nexport type FrameType = (typeof FrameType)[keyof typeof FrameType]\n\n/** Header size in bytes: type(1) + streamId(4) + length(4) */\nexport const FRAME_HEADER_SIZE = 9\n\n/** Current protocol version for framed responses */\nexport const TSS_FRAMED_PROTOCOL_VERSION = 1\n\n/** Full Content-Type header value with version parameter */\nexport const TSS_CONTENT_TYPE_FRAMED_VERSIONED = `${TSS_CONTENT_TYPE_FRAMED}; v=${TSS_FRAMED_PROTOCOL_VERSION}`\n\n/**\n * Parses the version parameter from a framed Content-Type header.\n * Returns undefined if no version parameter is present.\n */\nconst FRAMED_VERSION_REGEX = /;\\s*v=(\\d+)/\nexport function parseFramedProtocolVersion(\n  contentType: string,\n): number | undefined {\n  // Match \"v=<number>\" in the content-type parameters\n  const match = contentType.match(FRAMED_VERSION_REGEX)\n  return match ? parseInt(match[1]!, 10) : undefined\n}\n\n/**\n * Validates that the server's protocol version is compatible with this client.\n * Throws an error if versions are incompatible.\n */\nexport function validateFramedProtocolVersion(contentType: string): void {\n  const serverVersion = parseFramedProtocolVersion(contentType)\n  if (serverVersion === undefined) {\n    // No version specified - assume compatible (backwards compat)\n    return\n  }\n  if (serverVersion !== TSS_FRAMED_PROTOCOL_VERSION) {\n    throw new Error(\n      `Incompatible framed protocol version: server=${serverVersion}, client=${TSS_FRAMED_PROTOCOL_VERSION}. ` +\n        `Please ensure client and server are using compatible versions.`,\n    )\n  }\n}\n\n/**\n * Minimal metadata about a server function, available to client middleware.\n * Only contains the function ID since name/filename may expose server internals.\n */\nexport interface ClientFnMeta {\n  /** The unique identifier for this server function */\n  id: string\n}\n\n/**\n * Full metadata about a server function, available to server middleware and server functions.\n * This information is embedded at compile time by the TanStack Start compiler.\n */\nexport interface ServerFnMeta extends ClientFnMeta {\n  /** The original variable name of the server function (e.g., \"myServerFn\") */\n  name: string\n  /** The source file path relative to the project root (e.g., \"src/routes/api.ts\") */\n  filename: string\n}\n\nexport {}\n"],"mappings":";AAAA,IAAa,uBAAuB;AACpC,IAAa,sBAAsB,OAAO,IAAI,sBAAsB;AACpE,IAAa,8BAA8B,OAAO,IAChD,8BACD;AAED,IAAa,mBAAmB;AAChC,IAAa,qBAAqB;AAClC,IAAa,gBAAgB;;AAG7B,IAAa,0BAA0B;;;;AAKvC,IAAa,YAAY;CAEvB,MAAM;CAEN,OAAO;CAEP,KAAK;CAEL,OAAO;CACR;;AAKD,IAAa,oBAAoB;;AAGjC,IAAa,8BAA8B;;AAG3C,IAAa,oCAAoC,GAAG,wBAAwB;;;;;AAM5E,IAAM,uBAAuB;AAC7B,SAAgB,2BACd,aACoB;CAEpB,MAAM,QAAQ,YAAY,MAAM,qBAAqB;AACrD,QAAO,QAAQ,SAAS,MAAM,IAAK,GAAG,GAAG,KAAA;;;;;;AAO3C,SAAgB,8BAA8B,aAA2B;CACvE,MAAM,gBAAgB,2BAA2B,YAAY;AAC7D,KAAI,kBAAkB,KAAA,EAEpB;AAEF,KAAI,kBAAA,EACF,OAAM,IAAI,MACR,gDAAgD,cAAc,4EAE/D"}

package/dist/esm/createMiddleware.d.ts

@@ -0,0 +1,195 @@
+import { StartInstanceOptions } from './createStart.js';
+import { AnyServerFn, ConstrainValidator, CustomFetch, Method } from './createServerFn.js';
+import { ClientFnMeta, ServerFnMeta } from './constants.js';
+import { AnyContext, Assign, Constrain, Expand, IntersectAssign, Register, ResolveValidatorInput, ResolveValidatorOutput, ValidateSerializableInput } from '@benjavicente/router-core';
+export type CreateMiddlewareFn<TRegister> = <TType extends MiddlewareType>(options?: {
+    type?: TType;
+}, __opts?: FunctionMiddlewareOptions<TRegister, unknown, undefined, undefined, undefined>) => CreateMiddlewareResult<TRegister, TType>;
+export declare const createMiddleware: CreateMiddlewareFn<{}>;
+export type MiddlewareType = 'request' | 'function';
+export type CreateMiddlewareResult<TRegister, TType extends MiddlewareType> = 'request' extends TType ? RequestMiddleware<TRegister> : FunctionMiddleware<TRegister>;
+export interface FunctionMiddleware<TRegister> extends FunctionMiddlewareAfterMiddleware<TRegister, unknown> {
+    middleware: <const TNewMiddlewares = undefined>(middlewares: Constrain<TNewMiddlewares, ReadonlyArray<AnyRequestMiddleware | AnyFunctionMiddleware>>) => FunctionMiddlewareAfterMiddleware<TRegister, TNewMiddlewares>;
+}
+export interface FunctionMiddlewareAfterMiddleware<TRegister, TMiddlewares> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, undefined, undefined, undefined, undefined, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, undefined, undefined, undefined>, FunctionMiddlewareClient<TRegister, TMiddlewares, undefined>, FunctionMiddlewareValidator<TRegister, TMiddlewares> {
+}
+export interface FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
+    '~types': FunctionMiddlewareTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext>;
+    options: FunctionMiddlewareOptions<TRegister, TMiddlewares, TInputValidator, TServerContext, TClientContext>;
+}
+export interface FunctionMiddlewareTypes<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerContext, in out TServerSendContext, in out TClientContext, in out TClientSendContext> {
+    type: 'function';
+    middlewares: TMiddlewares;
+    input: ResolveValidatorInput<TInputValidator>;
+    allInput: IntersectAllValidatorInputs<TMiddlewares, TInputValidator>;
+    output: ResolveValidatorOutput<TInputValidator>;
+    allOutput: IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>;
+    clientContext: TClientContext;
+    allClientContextBeforeNext: AssignAllClientContextBeforeNext<TMiddlewares, TClientContext>;
+    allClientContextAfterNext: AssignAllClientContextAfterNext<TMiddlewares, TClientContext, TClientSendContext>;
+    serverContext: TServerContext;
+    serverSendContext: TServerSendContext;
+    allServerSendContext: AssignAllServerSendContext<TMiddlewares, TServerSendContext>;
+    allServerContext: AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext, TServerContext>;
+    clientSendContext: TClientSendContext;
+    allClientSendContext: AssignAllClientSendContext<TMiddlewares, TClientSendContext>;
+    inputValidator: TInputValidator;
+}
+/**
+ * Recursively resolve the input type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorInputs<TMiddlewares, TInputValidator> = unknown extends TInputValidator ? TInputValidator : TInputValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allInput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allInput'>, ResolveValidatorInput<TInputValidator>>;
+export type IntersectAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['~types'] | keyof AnyRequestMiddleware['~types'] | keyof AnyServerFn['~types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware | AnyServerFn ? IntersectAllMiddleware<TRest, TType, IntersectAssign<TAcc, TMiddleware['~types'][TType & keyof TMiddleware['~types']]>> : TAcc : TAcc;
+export type AnyFunctionMiddleware = FunctionMiddlewareWithTypes<any, any, any, any, any, any, any>;
+/**
+ * Recursively merge the output type produced by a sequence of middleware
+ */
+export type IntersectAllValidatorOutputs<TMiddlewares, TInputValidator> = unknown extends TInputValidator ? TInputValidator : TInputValidator extends undefined ? IntersectAllMiddleware<TMiddlewares, 'allOutput'> : IntersectAssign<IntersectAllMiddleware<TMiddlewares, 'allOutput'>, Awaited<ResolveValidatorOutput<TInputValidator>>>;
+/**
+ * Recursively resolve the client context type produced by a sequence of middleware
+ */
+export type AssignAllClientContextBeforeNext<TMiddlewares, TClientContext = undefined> = unknown extends TClientContext ? TClientContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextBeforeNext'>, TClientContext>;
+export type AssignAllMiddleware<TMiddlewares, TType extends keyof AnyFunctionMiddleware['~types'] | keyof AnyRequestMiddleware['~types'] | keyof AnyServerFn['~types'], TAcc = undefined> = TMiddlewares extends readonly [infer TMiddleware, ...infer TRest] ? TMiddleware extends AnyFunctionMiddleware | AnyRequestMiddleware | AnyServerFn ? AssignAllMiddleware<TRest, TType, Assign<TAcc, TMiddleware['~types'][TType & keyof TMiddleware['~types']]>> : TAcc : TAcc;
+export type AssignAllClientContextAfterNext<TMiddlewares, TClientContext = undefined, TSendContext = undefined> = unknown extends TClientContext ? Assign<TClientContext, TSendContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allClientContextAfterNext'>, Assign<TClientContext, TSendContext>>;
+export type AssignAllServerSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allServerSendContext'>, TSendContext>;
+export type AssignAllServerRequestContext<TRegister, TMiddlewares, TSendContext = undefined, TServerContext = undefined> = Assign<GlobalFetchRequestContext, Assign<GlobalServerRequestContext<TRegister>, __AssignAllServerRequestContext<TMiddlewares, TSendContext, TServerContext>>>;
+export type GlobalFetchRequestContext = Register extends {
+    server: {
+        requestContext: infer TRequestContext;
+    };
+} ? TRequestContext : AnyContext;
+export type GlobalServerRequestContext<TRegister> = TRegister extends {
+    config: StartInstanceOptions<any, any, infer TRequestMiddlewares, any>;
+} ? AssignAllMiddleware<TRequestMiddlewares, 'allServerContext'> : AnyContext;
+type __AssignAllServerRequestContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
+export type AssignAllServerFnContext<TRegister, TMiddlewares, TSendContext = undefined, TServerContext = undefined> = Assign<GlobalFetchRequestContext, Assign<GlobalServerRequestContext<TRegister>, // TODO: This enabled global middleware
+Assign<GlobalServerFnContext<TRegister>, // TODO: This enabled global middleware
+__AssignAllServerFnContext<TMiddlewares, TSendContext, TServerContext>>>>;
+type GlobalServerFnContext<TRegister> = TRegister extends {
+    config: StartInstanceOptions<any, any, any, infer TFunctionMiddlewares>;
+} ? AssignAllMiddleware<TFunctionMiddlewares, 'allServerContext'> : AnyContext;
+type __AssignAllServerFnContext<TMiddlewares, TSendContext = undefined, TServerContext = undefined> = unknown extends TSendContext ? Assign<TSendContext, TServerContext> : Assign<AssignAllMiddleware<TMiddlewares, 'allServerContext'>, Assign<TSendContext, TServerContext>>;
+export type AssignAllClientSendContext<TMiddlewares, TSendContext = undefined> = unknown extends TSendContext ? TSendContext : Assign<AssignAllMiddleware<TMiddlewares, 'allClientSendContext'>, TSendContext>;
+export interface FunctionMiddlewareOptions<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerContext, in out TClientContext> {
+    middleware?: TMiddlewares;
+    inputValidator?: ConstrainValidator<TRegister, 'GET', TInputValidator>;
+    client?: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TServerContext, TClientContext>;
+    server?: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerContext, unknown, unknown>;
+}
+export type FunctionMiddlewareClientNextFn<TRegister, TMiddlewares> = <TSendContext = undefined, TNewClientContext = undefined>(ctx?: {
+    context?: TNewClientContext;
+    sendContext?: ValidateSerializableInput<TRegister, TSendContext>;
+    headers?: HeadersInit;
+    fetch?: CustomFetch;
+}) => Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TNewClientContext>>;
+export interface FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> {
+    server: <TNewServerContext = undefined, TSendContext = undefined>(server: FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TNewServerContext, TSendContext>) => FunctionMiddlewareAfterServer<TRegister, TMiddlewares, TInputValidator, TNewServerContext, TServerSendContext, TClientContext, TSendContext>;
+}
+export type FunctionMiddlewareServerFn<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TNewServerContext, TSendContext> = (options: FunctionMiddlewareServerFnOptions<TRegister, TMiddlewares, TInputValidator, TServerSendContext>) => FunctionMiddlewareServerFnResult<TRegister, TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>;
+export type FunctionMiddlewareServerNextFn<TRegister, TMiddlewares, TServerSendContext> = <TNewServerContext = undefined, TSendContext = undefined>(ctx?: {
+    context?: TNewServerContext;
+    sendContext?: ValidateSerializableInput<TRegister, TSendContext>;
+}) => Promise<FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TNewServerContext, TSendContext>>;
+export type FunctionServerResultWithContext<in out TRegister, in out TMiddlewares, in out TServerSendContext, in out TServerContext, in out TSendContext> = {
+    'use functions must return the result of next()': true;
+    '~types': {
+        context: TServerContext;
+        sendContext: TSendContext;
+    };
+    context: Expand<AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext, TServerContext>>;
+    sendContext: Expand<AssignAllClientSendContext<TMiddlewares, TSendContext>>;
+};
+export interface FunctionMiddlewareServerFnOptions<in out TRegister, in out TMiddlewares, in out TInputValidator, in out TServerSendContext> {
+    data: Expand<IntersectAllValidatorOutputs<TMiddlewares, TInputValidator>>;
+    context: Expand<AssignAllServerFnContext<TRegister, TMiddlewares, TServerSendContext>>;
+    next: FunctionMiddlewareServerNextFn<TRegister, TMiddlewares, TServerSendContext>;
+    method: Method;
+    serverFnMeta: ServerFnMeta;
+    signal: AbortSignal;
+}
+export type FunctionMiddlewareServerFnResult<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext> = Promise<FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext>> | FunctionServerResultWithContext<TRegister, TMiddlewares, TServerSendContext, TServerContext, TSendContext>;
+export interface FunctionMiddlewareAfterServer<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, TServerContext, TServerSendContext, TClientContext, TClientSendContext> {
+}
+export interface FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {
+    client: <TSendServerContext = undefined, TNewClientContext = undefined>(client: FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TSendServerContext, TNewClientContext>) => FunctionMiddlewareAfterClient<TRegister, TMiddlewares, TInputValidator, TSendServerContext, TNewClientContext>;
+}
+export type FunctionMiddlewareClientFn<TRegister, TMiddlewares, TInputValidator, TSendContext, TClientContext> = (options: FunctionMiddlewareClientFnOptions<TRegister, TMiddlewares, TInputValidator>) => FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext>;
+export interface FunctionMiddlewareClientFnOptions<in out TRegister, in out TMiddlewares, in out TInputValidator> {
+    data: Expand<IntersectAllValidatorInputs<TMiddlewares, TInputValidator>>;
+    context: Expand<AssignAllClientContextBeforeNext<TMiddlewares>>;
+    sendContext: Expand<AssignAllServerSendContext<TMiddlewares>>;
+    method: Method;
+    signal: AbortSignal;
+    serverFnMeta: ClientFnMeta;
+    next: FunctionMiddlewareClientNextFn<TRegister, TMiddlewares>;
+    filename: string;
+    fetch?: CustomFetch;
+}
+export type FunctionMiddlewareClientFnResult<TMiddlewares, TSendContext, TClientContext> = Promise<FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>> | FunctionClientResultWithContext<TMiddlewares, TSendContext, TClientContext>;
+export type FunctionClientResultWithContext<in out TMiddlewares, in out TSendContext, in out TClientContext> = {
+    'use functions must return the result of next()': true;
+    context: Expand<AssignAllClientContextAfterNext<TMiddlewares, TClientContext>>;
+    sendContext: Expand<AssignAllServerSendContext<TMiddlewares, TSendContext>>;
+    headers: HeadersInit;
+    fetch?: CustomFetch;
+};
+export interface FunctionMiddlewareAfterClient<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, undefined, TServerSendContext, TClientContext, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, TServerSendContext, TClientContext> {
+}
+export interface FunctionMiddlewareValidator<TRegister, TMiddlewares> {
+    inputValidator: <TNewValidator>(inputValidator: ConstrainValidator<TRegister, 'GET', TNewValidator>) => FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TNewValidator>;
+}
+export interface FunctionMiddlewareAfterValidator<TRegister, TMiddlewares, TInputValidator> extends FunctionMiddlewareWithTypes<TRegister, TMiddlewares, TInputValidator, undefined, undefined, undefined, undefined>, FunctionMiddlewareServer<TRegister, TMiddlewares, TInputValidator, undefined, undefined>, FunctionMiddlewareClient<TRegister, TMiddlewares, TInputValidator> {
+}
+export interface RequestMiddleware<TRegister> extends RequestMiddlewareAfterMiddleware<TRegister, undefined> {
+    middleware: <const TMiddlewares = undefined>(middlewares: Constrain<TMiddlewares, ReadonlyArray<AnyRequestMiddleware>>) => RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares>;
+}
+export type AnyRequestMiddleware = RequestMiddlewareWithTypes<any, any, any>;
+export interface RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {
+    '~types': RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext>;
+    options: RequestMiddlewareOptions<TRegister, TMiddlewares, TServerContext>;
+}
+export interface RequestMiddlewareOptions<in out TRegister, in out TMiddlewares, in out TServerContext> {
+    middleware?: TMiddlewares;
+    server?: RequestServerFn<TRegister, TMiddlewares, TServerContext>;
+}
+export interface RequestMiddlewareTypes<TRegister, TMiddlewares, TServerContext> {
+    type: 'request';
+    allInput: undefined;
+    allOutput: undefined;
+    middlewares: TMiddlewares;
+    serverContext: TServerContext;
+    allServerContext: AssignAllServerRequestContext<TRegister, TMiddlewares, undefined, TServerContext>;
+}
+export interface RequestMiddlewareAfterMiddleware<TRegister, TMiddlewares> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, undefined>, RequestMiddlewareServer<TRegister, TMiddlewares> {
+}
+export interface RequestMiddlewareServer<TRegister, TMiddlewares> {
+    server: <TServerContext = undefined>(fn: RequestServerFn<TRegister, TMiddlewares, TServerContext>) => RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext>;
+}
+export type RequestServerFn<TRegister, TMiddlewares, TServerContext> = (options: RequestServerOptions<TRegister, TMiddlewares>) => RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext>;
+export interface RequestServerOptions<TRegister, TMiddlewares> {
+    request: Request;
+    pathname: string;
+    context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares>>;
+    next: RequestServerNextFn<TRegister, TMiddlewares>;
+    /**
+     * Metadata about the server function being invoked.
+     * This is only present when the request is handling a server function call.
+     * For regular page requests, this will be undefined.
+     */
+    serverFnMeta?: ServerFnMeta;
+}
+export type RequestServerNextFn<TRegister, TMiddlewares> = <TServerContext = undefined>(options?: RequestServerNextFnOptions<TServerContext>) => RequestServerNextFnResult<TRegister, TMiddlewares, TServerContext>;
+export interface RequestServerNextFnOptions<TServerContext> {
+    context?: TServerContext;
+}
+export type RequestServerNextFnResult<TRegister, TMiddlewares, TServerContext> = Promise<RequestServerResult<TRegister, TMiddlewares, TServerContext>> | RequestServerResult<TRegister, TMiddlewares, TServerContext>;
+export type RequestMiddlewareServerFnResult<TRegister, TMiddlewares, TServerContext> = Promise<RequestServerResult<TRegister, TMiddlewares, TServerContext> | Response> | RequestServerResult<TRegister, TMiddlewares, TServerContext> | Response;
+export interface RequestServerResult<TRegister, TMiddlewares, TServerContext> {
+    request: Request;
+    pathname: string;
+    context: Expand<AssignAllServerRequestContext<TRegister, TMiddlewares, undefined, TServerContext>>;
+    response: Response;
+}
+export interface RequestMiddlewareAfterServer<TRegister, TMiddlewares, TServerContext> extends RequestMiddlewareWithTypes<TRegister, TMiddlewares, TServerContext> {
+}
+export {};

package/dist/esm/createMiddleware.js

@@ -0,0 +1,26 @@
+//#region src/createMiddleware.ts
+var createMiddleware = (options, __opts) => {
+	const resolvedOptions = {
+		type: "request",
+		...__opts || options
+	};
+	return {
+		options: resolvedOptions,
+		middleware: (middleware) => {
+			return createMiddleware({}, Object.assign(resolvedOptions, { middleware }));
+		},
+		inputValidator: (inputValidator) => {
+			return createMiddleware({}, Object.assign(resolvedOptions, { inputValidator }));
+		},
+		client: (client) => {
+			return createMiddleware({}, Object.assign(resolvedOptions, { client }));
+		},
+		server: (server) => {
+			return createMiddleware({}, Object.assign(resolvedOptions, { server }));
+		}
+	};
+};
+//#endregion
+export { createMiddleware };
+
+//# sourceMappingURL=createMiddleware.js.map