@benjavicente/router-core 1.168.9

package/dist/cjs/ssr/serializer/transformer.d.cts

@@ -0,0 +1,91 @@
+import { Plugin, SerovalNode } from 'seroval';
+import { RegisteredConfigType, RegisteredSsr, SSROption } from '../../router.cjs';
+import { LooseReturnType } from '../../utils.cjs';
+import { AnyRoute, ResolveAllSSR } from '../../route.cjs';
+import { RawStream } from './RawStream.cjs';
+declare const TSR_SERIALIZABLE: unique symbol;
+export type TSR_SERIALIZABLE = typeof TSR_SERIALIZABLE;
+export type TsrSerializable = {
+    [TSR_SERIALIZABLE]: true;
+};
+export interface DefaultSerializable {
+    number: number;
+    string: string;
+    boolean: boolean;
+    null: null;
+    undefined: undefined;
+    bigint: bigint;
+    Date: Date;
+    Uint8Array: Uint8Array;
+    RawStream: RawStream;
+    TsrSerializable: TsrSerializable;
+}
+export interface SerializableExtensions extends DefaultSerializable {
+}
+export type Serializable = SerializableExtensions[keyof SerializableExtensions];
+export type UnionizeSerializationAdaptersInput<TAdapters extends ReadonlyArray<AnySerializationAdapter>> = TAdapters[number]['~types']['input'];
+/**
+ * Create a strongly-typed serialization adapter for SSR hydration.
+ * Use to register custom types with the router serializer.
+ */
+export declare function createSerializationAdapter<TInput = unknown, TOutput = unknown, const TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter> | never = never>(opts: CreateSerializationAdapterOptions<TInput, TOutput, TExtendsAdapters>): SerializationAdapter<TInput, TOutput, TExtendsAdapters>;
+export interface CreateSerializationAdapterOptions<TInput, TOutput, TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter> | never> {
+    key: string;
+    extends?: TExtendsAdapters;
+    test: (value: unknown) => value is TInput;
+    toSerializable: (value: TInput) => ValidateSerializable<TOutput, Serializable | UnionizeSerializationAdaptersInput<TExtendsAdapters>>;
+    fromSerializable: (value: TOutput) => TInput;
+}
+export type ValidateSerializable<T, TSerializable> = T extends ReadonlyArray<unknown> ? ResolveArrayShape<T, TSerializable, 'input'> : T extends TSerializable ? T : T extends (...args: Array<any>) => any ? 'Function is not serializable' : T extends Promise<any> ? ValidateSerializablePromise<T, TSerializable> : T extends ReadableStream<any> ? ValidateReadableStream<T, TSerializable> : T extends Set<any> ? ValidateSerializableSet<T, TSerializable> : T extends Map<any, any> ? ValidateSerializableMap<T, TSerializable> : T extends AsyncGenerator<any, any> ? ValidateSerializableAsyncGenerator<T, TSerializable> : {
+    [K in keyof T]: ValidateSerializable<T[K], TSerializable>;
+};
+export type ValidateSerializableAsyncGenerator<T, TSerializable> = T extends AsyncGenerator<infer T, infer TReturn, infer TNext> ? AsyncGenerator<ValidateSerializable<T, TSerializable>, ValidateSerializable<TReturn, TSerializable>, TNext> : never;
+export type ValidateSerializablePromise<T, TSerializable> = T extends Promise<infer TAwaited> ? Promise<ValidateSerializable<TAwaited, TSerializable>> : never;
+export type ValidateReadableStream<T, TSerializable> = T extends ReadableStream<infer TStreamed> ? ReadableStream<ValidateSerializable<TStreamed, TSerializable>> : never;
+export type ValidateSerializableSet<T, TSerializable> = T extends Set<infer TItem> ? Set<ValidateSerializable<TItem, TSerializable>> : never;
+export type ValidateSerializableMap<T, TSerializable> = T extends Map<infer TKey, infer TValue> ? Map<ValidateSerializable<TKey, TSerializable>, ValidateSerializable<TValue, TSerializable>> : never;
+export type RegisteredReadableStream = unknown extends SerializerExtensions['ReadableStream'] ? never : SerializerExtensions['ReadableStream'];
+export interface DefaultSerializerExtensions {
+    ReadableStream: unknown;
+}
+export interface SerializerExtensions extends DefaultSerializerExtensions {
+}
+export interface SerializationAdapter<TInput, TOutput, TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter>> {
+    '~types': SerializationAdapterTypes<TInput, TOutput, TExtendsAdapters>;
+    key: string;
+    extends?: TExtendsAdapters;
+    test: (value: unknown) => value is TInput;
+    toSerializable: (value: TInput) => TOutput;
+    fromSerializable: (value: TOutput) => TInput;
+}
+export interface SerializationAdapterTypes<TInput, TOutput, TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter>> {
+    input: TInput | UnionizeSerializationAdaptersInput<TExtendsAdapters>;
+    output: TOutput;
+    extends: TExtendsAdapters;
+}
+export type AnySerializationAdapter = SerializationAdapter<any, any, any>;
+/** Create a Seroval plugin for server-side serialization only. */
+export declare function makeSsrSerovalPlugin(serializationAdapter: AnySerializationAdapter, options: {
+    didRun: boolean;
+}): Plugin<any, SerovalNode>;
+/** Create a Seroval plugin for client/server symmetric (de)serialization. */
+export declare function makeSerovalPlugin(serializationAdapter: AnySerializationAdapter): Plugin<any, SerovalNode>;
+export type ValidateSerializableInput<TRegister, T> = ValidateSerializable<T, RegisteredSerializableInput<TRegister>>;
+export type RegisteredSerializableInput<TRegister> = (unknown extends RegisteredSerializationAdapters<TRegister> ? never : RegisteredSerializationAdapters<TRegister> extends ReadonlyArray<AnySerializationAdapter> ? RegisteredSerializationAdapters<TRegister>[number]['~types']['input'] : never) | Serializable;
+export type RegisteredSerializationAdapters<TRegister> = RegisteredConfigType<TRegister, 'serializationAdapters'>;
+export type ValidateSerializableInputResult<TRegister, T> = ValidateSerializableResult<T, RegisteredSerializableInput<TRegister>>;
+export type ValidateSerializableResult<T, TSerializable> = T extends ReadonlyArray<unknown> ? ResolveArrayShape<T, TSerializable, 'result'> : T extends TSerializable ? T : unknown extends SerializerExtensions['ReadableStream'] ? {
+    [K in keyof T]: ValidateSerializableResult<T[K], TSerializable>;
+} : T extends SerializerExtensions['ReadableStream'] ? ReadableStream : {
+    [K in keyof T]: ValidateSerializableResult<T[K], TSerializable>;
+};
+export type RegisteredSSROption<TRegister> = unknown extends RegisteredConfigType<TRegister, 'defaultSsr'> ? SSROption : RegisteredConfigType<TRegister, 'defaultSsr'>;
+export type ValidateSerializableLifecycleResult<TRegister, TParentRoute extends AnyRoute, TSSR, TFn> = false extends RegisteredSsr<TRegister> ? any : ValidateSerializableLifecycleResultSSR<TRegister, TParentRoute, TSSR, TFn> extends infer TInput ? TInput : never;
+export type ValidateSerializableLifecycleResultSSR<TRegister, TParentRoute extends AnyRoute, TSSR, TFn> = ResolveAllSSR<TParentRoute, TSSR> extends false ? any : RegisteredSSROption<TRegister> extends false ? any : ValidateSerializableInput<TRegister, LooseReturnType<TFn>>;
+type ResolveArrayShape<T extends ReadonlyArray<unknown>, TSerializable, TMode extends 'input' | 'result'> = number extends T['length'] ? T extends Array<infer U> ? Array<ArrayModeResult<TMode, U, TSerializable>> : ReadonlyArray<ArrayModeResult<TMode, T[number], TSerializable>> : ResolveTupleShape<T, TSerializable, TMode>;
+type ResolveTupleShape<T extends ReadonlyArray<unknown>, TSerializable, TMode extends 'input' | 'result'> = T extends readonly [infer THead, ...infer TTail] ? readonly [
+    ArrayModeResult<TMode, THead, TSerializable>,
+    ...ResolveTupleShape<Readonly<TTail>, TSerializable, TMode>
+] : T;
+type ArrayModeResult<TMode extends 'input' | 'result', TValue, TSerializable> = TMode extends 'input' ? ValidateSerializable<TValue, TSerializable> : ValidateSerializableResult<TValue, TSerializable>;
+export {};

package/dist/cjs/ssr/server.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_ssr_server = require("./ssr-server.cjs");
+const require_createRequestHandler = require("./createRequestHandler.cjs");
+const require_handlerCallback = require("./handlerCallback.cjs");
+const require_transformStreamWithRouter = require("./transformStreamWithRouter.cjs");
+exports.attachRouterServerSsrUtils = require_ssr_server.attachRouterServerSsrUtils;
+exports.createRequestHandler = require_createRequestHandler.createRequestHandler;
+exports.defineHandlerCallback = require_handlerCallback.defineHandlerCallback;
+exports.getNormalizedURL = require_ssr_server.getNormalizedURL;
+exports.getOrigin = require_ssr_server.getOrigin;
+exports.transformPipeableStreamWithRouter = require_transformStreamWithRouter.transformPipeableStreamWithRouter;
+exports.transformReadableStreamWithRouter = require_transformStreamWithRouter.transformReadableStreamWithRouter;
+exports.transformStreamWithRouter = require_transformStreamWithRouter.transformStreamWithRouter;

package/dist/cjs/ssr/server.d.cts

@@ -0,0 +1,6 @@
+export { createRequestHandler } from './createRequestHandler.cjs';
+export type { RequestHandler } from './createRequestHandler.cjs';
+export { defineHandlerCallback } from './handlerCallback.cjs';
+export type { HandlerCallback } from './handlerCallback.cjs';
+export { transformPipeableStreamWithRouter, transformStreamWithRouter, transformReadableStreamWithRouter, } from './transformStreamWithRouter.cjs';
+export { attachRouterServerSsrUtils, getNormalizedURL, getOrigin, } from './ssr-server.cjs';

package/dist/cjs/ssr/ssr-client.cjs

@@ -0,0 +1,183 @@
+const require_utils = require("../utils.cjs");
+const require_invariant = require("../invariant.cjs");
+const require_not_found = require("../not-found.cjs");
+const require_ssr_match_id = require("./ssr-match-id.cjs");
+//#region src/ssr/ssr-client.ts
+function hydrateMatch(match, deyhydratedMatch) {
+	match.id = deyhydratedMatch.i;
+	match.__beforeLoadContext = deyhydratedMatch.b;
+	match.loaderData = deyhydratedMatch.l;
+	match.status = deyhydratedMatch.s;
+	match.ssr = deyhydratedMatch.ssr;
+	match.updatedAt = deyhydratedMatch.u;
+	match.error = deyhydratedMatch.e;
+	if (deyhydratedMatch.g !== void 0) match.globalNotFound = deyhydratedMatch.g;
+}
+async function hydrate(router) {
+	if (!window.$_TSR) {
+		if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: Expected to find bootstrap data on window.$_TSR, but we did not. Please file an issue!");
+		require_invariant.invariant();
+	}
+	const serializationAdapters = router.options.serializationAdapters;
+	if (serializationAdapters?.length) {
+		const fromSerializableMap = /* @__PURE__ */ new Map();
+		serializationAdapters.forEach((adapter) => {
+			fromSerializableMap.set(adapter.key, adapter.fromSerializable);
+		});
+		window.$_TSR.t = fromSerializableMap;
+		window.$_TSR.buffer.forEach((script) => script());
+	}
+	window.$_TSR.initialized = true;
+	if (!window.$_TSR.router) {
+		if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: Expected to find a dehydrated data on window.$_TSR.router, but we did not. Please file an issue!");
+		require_invariant.invariant();
+	}
+	const dehydratedRouter = window.$_TSR.router;
+	dehydratedRouter.matches.forEach((dehydratedMatch) => {
+		dehydratedMatch.i = require_ssr_match_id.hydrateSsrMatchId(dehydratedMatch.i);
+	});
+	if (dehydratedRouter.lastMatchId) dehydratedRouter.lastMatchId = require_ssr_match_id.hydrateSsrMatchId(dehydratedRouter.lastMatchId);
+	const { manifest, dehydratedData, lastMatchId } = dehydratedRouter;
+	router.ssr = { manifest };
+	const nonce = document.querySelector("meta[property=\"csp-nonce\"]")?.content;
+	router.options.ssr = { nonce };
+	const matches = router.matchRoutes(router.stores.location.state);
+	const routeChunkPromise = Promise.all(matches.map((match) => router.loadRouteChunk(router.looseRoutesById[match.routeId])));
+	function setMatchForcePending(match) {
+		const pendingMinMs = router.looseRoutesById[match.routeId].options.pendingMinMs ?? router.options.defaultPendingMinMs;
+		if (pendingMinMs) {
+			const minPendingPromise = require_utils.createControlledPromise();
+			match._nonReactive.minPendingPromise = minPendingPromise;
+			match._forcePending = true;
+			setTimeout(() => {
+				minPendingPromise.resolve();
+				router.updateMatch(match.id, (prev) => {
+					prev._nonReactive.minPendingPromise = void 0;
+					return {
+						...prev,
+						_forcePending: void 0
+					};
+				});
+			}, pendingMinMs);
+		}
+	}
+	function setRouteSsr(match) {
+		const route = router.looseRoutesById[match.routeId];
+		if (route) route.options.ssr = match.ssr;
+	}
+	let firstNonSsrMatchIndex = void 0;
+	matches.forEach((match) => {
+		const dehydratedMatch = dehydratedRouter.matches.find((d) => d.i === match.id);
+		if (!dehydratedMatch) {
+			match._nonReactive.dehydrated = false;
+			match.ssr = false;
+			setRouteSsr(match);
+			return;
+		}
+		hydrateMatch(match, dehydratedMatch);
+		setRouteSsr(match);
+		match._nonReactive.dehydrated = match.ssr !== false;
+		if (match.ssr === "data-only" || match.ssr === false) {
+			if (firstNonSsrMatchIndex === void 0) {
+				firstNonSsrMatchIndex = match.index;
+				setMatchForcePending(match);
+			}
+		}
+	});
+	router.stores.setActiveMatches(matches);
+	await router.options.hydrate?.(dehydratedData);
+	const activeMatches = router.stores.activeMatchesSnapshot.state;
+	const location = router.stores.location.state;
+	await Promise.all(activeMatches.map(async (match) => {
+		try {
+			const route = router.looseRoutesById[match.routeId];
+			const parentContext = activeMatches[match.index - 1]?.context ?? router.options.context;
+			if (route.options.context) {
+				const contextFnContext = {
+					deps: match.loaderDeps,
+					params: match.params,
+					context: parentContext ?? {},
+					location,
+					navigate: (opts) => router.navigate({
+						...opts,
+						_fromLocation: location
+					}),
+					buildLocation: router.buildLocation,
+					cause: match.cause,
+					abortController: match.abortController,
+					preload: false,
+					matches,
+					routeId: route.id
+				};
+				match.__routeContext = route.options.context(contextFnContext) ?? void 0;
+			}
+			match.context = {
+				...parentContext,
+				...match.__routeContext,
+				...match.__beforeLoadContext
+			};
+			const assetContext = {
+				ssr: router.options.ssr,
+				matches: activeMatches,
+				match,
+				params: match.params,
+				loaderData: match.loaderData
+			};
+			const headFnContent = await route.options.head?.(assetContext);
+			const scripts = await route.options.scripts?.(assetContext);
+			match.meta = headFnContent?.meta;
+			match.links = headFnContent?.links;
+			match.headScripts = headFnContent?.scripts;
+			match.styles = headFnContent?.styles;
+			match.scripts = scripts;
+		} catch (err) {
+			if (require_not_found.isNotFound(err)) {
+				match.error = { isNotFound: true };
+				console.error(`NotFound error during hydration for routeId: ${match.routeId}`, err);
+			} else {
+				match.error = err;
+				console.error(`Error during hydration for route ${match.routeId}:`, err);
+				throw err;
+			}
+		}
+	}));
+	const isSpaMode = matches[matches.length - 1].id !== lastMatchId;
+	if (!matches.some((m) => m.ssr === false) && !isSpaMode) {
+		matches.forEach((match) => {
+			match._nonReactive.dehydrated = void 0;
+		});
+		router.stores.resolvedLocation.setState(() => router.stores.location.state);
+		return routeChunkPromise;
+	}
+	const loadPromise = Promise.resolve().then(() => router.load()).catch((err) => {
+		console.error("Error during router hydration:", err);
+	});
+	if (isSpaMode) {
+		const match = matches[1];
+		if (!match) {
+			if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: Expected to find a match below the root match in SPA mode.");
+			require_invariant.invariant();
+		}
+		setMatchForcePending(match);
+		match._displayPending = true;
+		match._nonReactive.displayPendingPromise = loadPromise;
+		loadPromise.then(() => {
+			router.batch(() => {
+				if (router.stores.status.state === "pending") router.batch(() => {
+					router.stores.status.setState(() => "idle");
+					router.stores.resolvedLocation.setState(() => router.stores.location.state);
+				});
+				router.updateMatch(match.id, (prev) => ({
+					...prev,
+					_displayPending: void 0,
+					displayPendingPromise: void 0
+				}));
+			});
+		});
+	}
+	return routeChunkPromise;
+}
+//#endregion
+exports.hydrate = hydrate;
+
+//# sourceMappingURL=ssr-client.cjs.map

package/dist/cjs/ssr/ssr-client.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-client.cjs","names":[],"sources":["../../../src/ssr/ssr-client.ts"],"sourcesContent":["import { invariant } from '../invariant'\nimport { isNotFound } from '../not-found'\nimport { createControlledPromise } from '../utils'\nimport { hydrateSsrMatchId } from './ssr-match-id'\nimport type { GLOBAL_SEROVAL, GLOBAL_TSR } from './constants'\nimport type { DehydratedMatch, TsrSsrGlobal } from './types'\nimport type { AnyRouteMatch } from '../Matches'\nimport type { AnyRouter } from '../router'\nimport type { RouteContextOptions } from '../route'\nimport type { AnySerializationAdapter } from './serializer/transformer'\n\ndeclare global {\n  interface Window {\n    [GLOBAL_TSR]?: TsrSsrGlobal\n    [GLOBAL_SEROVAL]?: any\n  }\n}\n\nfunction hydrateMatch(\n  match: AnyRouteMatch,\n  deyhydratedMatch: DehydratedMatch,\n): void {\n  match.id = deyhydratedMatch.i\n  match.__beforeLoadContext = deyhydratedMatch.b\n  match.loaderData = deyhydratedMatch.l\n  match.status = deyhydratedMatch.s\n  match.ssr = deyhydratedMatch.ssr\n  match.updatedAt = deyhydratedMatch.u\n  match.error = deyhydratedMatch.e\n  // Only hydrate global-not-found when a defined value is present in the\n  // dehydrated payload. If omitted, preserve the value computed from the\n  // current client location (important for SPA fallback HTML served at unknown\n  // URLs, where dehydrated matches may come from `/` but client matching marks\n  // root as globalNotFound).\n  if (deyhydratedMatch.g !== undefined) {\n    match.globalNotFound = deyhydratedMatch.g\n  }\n}\n\nexport async function hydrate(router: AnyRouter): Promise<any> {\n  if (!window.$_TSR) {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error(\n        'Invariant failed: Expected to find bootstrap data on window.$_TSR, but we did not. Please file an issue!',\n      )\n    }\n\n    invariant()\n  }\n\n  const serializationAdapters = router.options.serializationAdapters as\n    | Array<AnySerializationAdapter>\n    | undefined\n\n  if (serializationAdapters?.length) {\n    const fromSerializableMap = new Map()\n    serializationAdapters.forEach((adapter) => {\n      fromSerializableMap.set(adapter.key, adapter.fromSerializable)\n    })\n    window.$_TSR.t = fromSerializableMap\n    window.$_TSR.buffer.forEach((script) => script())\n  }\n  window.$_TSR.initialized = true\n\n  if (!window.$_TSR.router) {\n    if (process.env.NODE_ENV !== 'production') {\n      throw new Error(\n        'Invariant failed: Expected to find a dehydrated data on window.$_TSR.router, but we did not. Please file an issue!',\n      )\n    }\n\n    invariant()\n  }\n\n  const dehydratedRouter = window.$_TSR.router\n  dehydratedRouter.matches.forEach((dehydratedMatch) => {\n    dehydratedMatch.i = hydrateSsrMatchId(dehydratedMatch.i)\n  })\n  if (dehydratedRouter.lastMatchId) {\n    dehydratedRouter.lastMatchId = hydrateSsrMatchId(\n      dehydratedRouter.lastMatchId,\n    )\n  }\n  const { manifest, dehydratedData, lastMatchId } = dehydratedRouter\n\n  router.ssr = {\n    manifest,\n  }\n  const meta = document.querySelector('meta[property=\"csp-nonce\"]') as\n    | HTMLMetaElement\n    | undefined\n  const nonce = meta?.content\n  router.options.ssr = {\n    nonce,\n  }\n\n  // Hydrate the router state\n  const matches = router.matchRoutes(router.stores.location.state)\n\n  // kick off loading the route chunks\n  const routeChunkPromise = Promise.all(\n    matches.map((match) =>\n      router.loadRouteChunk(router.looseRoutesById[match.routeId]!),\n    ),\n  )\n\n  function setMatchForcePending(match: AnyRouteMatch) {\n    // usually the minPendingPromise is created in the Match component if a pending match is rendered\n    // however, this might be too late if the match synchronously resolves\n    const route = router.looseRoutesById[match.routeId]!\n    const pendingMinMs =\n      route.options.pendingMinMs ?? router.options.defaultPendingMinMs\n    if (pendingMinMs) {\n      const minPendingPromise = createControlledPromise<void>()\n      match._nonReactive.minPendingPromise = minPendingPromise\n      match._forcePending = true\n\n      setTimeout(() => {\n        minPendingPromise.resolve()\n        // We've handled the minPendingPromise, so we can delete it\n        router.updateMatch(match.id, (prev) => {\n          prev._nonReactive.minPendingPromise = undefined\n          return {\n            ...prev,\n            _forcePending: undefined,\n          }\n        })\n      }, pendingMinMs)\n    }\n  }\n\n  function setRouteSsr(match: AnyRouteMatch) {\n    const route = router.looseRoutesById[match.routeId]\n    if (route) {\n      route.options.ssr = match.ssr\n    }\n  }\n  // Right after hydration and before the first render, we need to rehydrate each match\n  // First step is to reyhdrate loaderData and __beforeLoadContext\n  let firstNonSsrMatchIndex: number | undefined = undefined\n  matches.forEach((match) => {\n    const dehydratedMatch = dehydratedRouter.matches.find(\n      (d) => d.i === match.id,\n    )\n    if (!dehydratedMatch) {\n      match._nonReactive.dehydrated = false\n      match.ssr = false\n      setRouteSsr(match)\n      return\n    }\n\n    hydrateMatch(match, dehydratedMatch)\n    setRouteSsr(match)\n\n    match._nonReactive.dehydrated = match.ssr !== false\n\n    if (match.ssr === 'data-only' || match.ssr === false) {\n      if (firstNonSsrMatchIndex === undefined) {\n        firstNonSsrMatchIndex = match.index\n        setMatchForcePending(match)\n      }\n    }\n  })\n\n  router.stores.setActiveMatches(matches)\n\n  // Allow the user to handle custom hydration data\n  await router.options.hydrate?.(dehydratedData)\n\n  // now that all necessary data is hydrated:\n  // 1) fully reconstruct the route context\n  // 2) execute `head()` and `scripts()` for each match\n  const activeMatches = router.stores.activeMatchesSnapshot.state\n  const location = router.stores.location.state\n  await Promise.all(\n    activeMatches.map(async (match) => {\n      try {\n        const route = router.looseRoutesById[match.routeId]!\n\n        const parentMatch = activeMatches[match.index - 1]\n        const parentContext = parentMatch?.context ?? router.options.context\n\n        // `context()` was already executed by `matchRoutes`, however route context was not yet fully reconstructed\n        // so run it again and merge route context\n        if (route.options.context) {\n          const contextFnContext: RouteContextOptions<any, any, any, any, any> =\n            {\n              deps: match.loaderDeps,\n              params: match.params,\n              context: parentContext ?? {},\n              location,\n              navigate: (opts: any) =>\n                router.navigate({\n                  ...opts,\n                  _fromLocation: location,\n                }),\n              buildLocation: router.buildLocation,\n              cause: match.cause,\n              abortController: match.abortController,\n              preload: false,\n              matches,\n              routeId: route.id,\n            }\n          match.__routeContext =\n            route.options.context(contextFnContext) ?? undefined\n        }\n\n        match.context = {\n          ...parentContext,\n          ...match.__routeContext,\n          ...match.__beforeLoadContext,\n        }\n\n        const assetContext = {\n          ssr: router.options.ssr,\n          matches: activeMatches,\n          match,\n          params: match.params,\n          loaderData: match.loaderData,\n        }\n        const headFnContent = await route.options.head?.(assetContext)\n\n        const scripts = await route.options.scripts?.(assetContext)\n\n        match.meta = headFnContent?.meta\n        match.links = headFnContent?.links\n        match.headScripts = headFnContent?.scripts\n        match.styles = headFnContent?.styles\n        match.scripts = scripts\n      } catch (err) {\n        if (isNotFound(err)) {\n          match.error = { isNotFound: true }\n          console.error(\n            `NotFound error during hydration for routeId: ${match.routeId}`,\n            err,\n          )\n        } else {\n          match.error = err as any\n          console.error(\n            `Error during hydration for route ${match.routeId}:`,\n            err,\n          )\n          throw err\n        }\n      }\n    }),\n  )\n\n  const isSpaMode = matches[matches.length - 1]!.id !== lastMatchId\n  const hasSsrFalseMatches = matches.some((m) => m.ssr === false)\n  // all matches have data from the server and we are not in SPA mode so we don't need to kick of router.load()\n  if (!hasSsrFalseMatches && !isSpaMode) {\n    matches.forEach((match) => {\n      // remove the dehydrated flag since we won't run router.load() which would remove it\n      match._nonReactive.dehydrated = undefined\n    })\n    // Mark the current location as resolved so that later load cycles\n    // (e.g. preloads, invalidations) don't mistakenly detect a href change\n    // (resolvedLocation defaults to undefined and router.load() is skipped\n    // in the normal SSR hydration path).\n    router.stores.resolvedLocation.setState(() => router.stores.location.state)\n    return routeChunkPromise\n  }\n\n  // schedule router.load() to run after the next tick so we can store the promise in the match before loading starts\n  const loadPromise = Promise.resolve()\n    .then(() => router.load())\n    .catch((err) => {\n      console.error('Error during router hydration:', err)\n    })\n\n  // in SPA mode we need to keep the first match below the root route pending until router.load() is finished\n  // this will prevent that other pending components are rendered but hydration is not blocked\n  if (isSpaMode) {\n    const match = matches[1]\n    if (!match) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          'Invariant failed: Expected to find a match below the root match in SPA mode.',\n        )\n      }\n\n      invariant()\n    }\n    setMatchForcePending(match)\n\n    match._displayPending = true\n    match._nonReactive.displayPendingPromise = loadPromise\n\n    loadPromise.then(() => {\n      router.batch(() => {\n        // ensure router is not in status 'pending' anymore\n        // this usually happens in Transitioner but if loading synchronously resolves,\n        // Transitioner won't be rendered while loading so it cannot track the change from loading:true to loading:false\n        if (router.stores.status.state === 'pending') {\n          router.batch(() => {\n            router.stores.status.setState(() => 'idle')\n            router.stores.resolvedLocation.setState(\n              () => router.stores.location.state,\n            )\n          })\n        }\n        // hide the pending component once the load is finished\n        router.updateMatch(match.id, (prev) => ({\n          ...prev,\n          _displayPending: undefined,\n          displayPendingPromise: undefined,\n        }))\n      })\n    })\n  }\n  return routeChunkPromise\n}\n"],"mappings":"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"}

package/dist/cjs/ssr/ssr-client.d.cts

@@ -0,0 +1,10 @@
+import { GLOBAL_SEROVAL, GLOBAL_TSR } from './constants.cjs';
+import { TsrSsrGlobal } from './types.cjs';
+import { AnyRouter } from '../router.cjs';
+declare global {
+    interface Window {
+        [GLOBAL_TSR]?: TsrSsrGlobal;
+        [GLOBAL_SEROVAL]?: any;
+    }
+}
+export declare function hydrate(router: AnyRouter): Promise<any>;

package/dist/cjs/ssr/ssr-match-id.cjs

@@ -0,0 +1,12 @@
+//#region src/ssr/ssr-match-id.ts
+function dehydrateSsrMatchId(id) {
+	return id.replaceAll("/", "\0");
+}
+function hydrateSsrMatchId(id) {
+	return id.replaceAll("\0", "/").replaceAll("�", "/");
+}
+//#endregion
+exports.dehydrateSsrMatchId = dehydrateSsrMatchId;
+exports.hydrateSsrMatchId = hydrateSsrMatchId;
+
+//# sourceMappingURL=ssr-match-id.cjs.map

package/dist/cjs/ssr/ssr-match-id.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-match-id.cjs","names":[],"sources":["../../../src/ssr/ssr-match-id.ts"],"sourcesContent":["export function dehydrateSsrMatchId(id: string): string {\n  return id.replaceAll('/', '\\0')\n}\n\nexport function hydrateSsrMatchId(id: string): string {\n  return id.replaceAll('\\0', '/').replaceAll('\\uFFFD', '/')\n}\n"],"mappings":";AAAA,SAAgB,oBAAoB,IAAoB;AACtD,QAAO,GAAG,WAAW,KAAK,KAAK;;AAGjC,SAAgB,kBAAkB,IAAoB;AACpD,QAAO,GAAG,WAAW,MAAM,IAAI,CAAC,WAAW,KAAU,IAAI"}

package/dist/cjs/ssr/ssr-match-id.d.cts

@@ -0,0 +1,2 @@
+export declare function dehydrateSsrMatchId(id: string): string;
+export declare function hydrateSsrMatchId(id: string): string;

package/dist/cjs/ssr/ssr-server.cjs

@@ -0,0 +1,279 @@
+const require_utils = require("../utils.cjs");
+const require_invariant = require("../invariant.cjs");
+const require_lru_cache = require("../lru-cache.cjs");
+const require_constants = require("./constants.cjs");
+const require_transformer = require("./serializer/transformer.cjs");
+const require_seroval_plugins = require("./serializer/seroval-plugins.cjs");
+const require_ssr_match_id = require("./ssr-match-id.cjs");
+const require_tsrScript = require("./tsrScript.cjs");
+let seroval = require("seroval");
+//#region src/ssr/ssr-server.ts
+var SCOPE_ID = "tsr";
+var TSR_PREFIX = require_constants.GLOBAL_TSR + ".router=";
+var P_PREFIX = require_constants.GLOBAL_TSR + ".p(()=>";
+var P_SUFFIX = ")";
+function dehydrateMatch(match) {
+	const dehydratedMatch = {
+		i: require_ssr_match_id.dehydrateSsrMatchId(match.id),
+		u: match.updatedAt,
+		s: match.status
+	};
+	for (const [key, shorthand] of [
+		["__beforeLoadContext", "b"],
+		["loaderData", "l"],
+		["error", "e"],
+		["ssr", "ssr"]
+	]) if (match[key] !== void 0) dehydratedMatch[shorthand] = match[key];
+	if (match.globalNotFound) dehydratedMatch.g = true;
+	return dehydratedMatch;
+}
+var INITIAL_SCRIPTS = [(0, seroval.getCrossReferenceHeader)(SCOPE_ID), require_tsrScript.default];
+var ScriptBuffer = class {
+	constructor(router) {
+		this._scriptBarrierLifted = false;
+		this._cleanedUp = false;
+		this._pendingMicrotask = false;
+		this.router = router;
+		this._queue = INITIAL_SCRIPTS.slice();
+	}
+	enqueue(script) {
+		if (this._cleanedUp) return;
+		this._queue.push(script);
+		if (this._scriptBarrierLifted && !this._pendingMicrotask) {
+			this._pendingMicrotask = true;
+			queueMicrotask(() => {
+				this._pendingMicrotask = false;
+				this.injectBufferedScripts();
+			});
+		}
+	}
+	liftBarrier() {
+		if (this._scriptBarrierLifted || this._cleanedUp) return;
+		this._scriptBarrierLifted = true;
+		if (this._queue.length > 0 && !this._pendingMicrotask) {
+			this._pendingMicrotask = true;
+			queueMicrotask(() => {
+				this._pendingMicrotask = false;
+				this.injectBufferedScripts();
+			});
+		}
+	}
+	/**
+	* Flushes any pending scripts synchronously.
+	* Call this before emitting onSerializationFinished to ensure all scripts are injected.
+	*
+	* IMPORTANT: Only injects if the barrier has been lifted. Before the barrier is lifted,
+	* scripts should remain in the queue so takeBufferedScripts() can retrieve them
+	*/
+	flush() {
+		if (!this._scriptBarrierLifted) return;
+		if (this._cleanedUp) return;
+		this._pendingMicrotask = false;
+		const scriptsToInject = this.takeAll();
+		if (scriptsToInject && this.router?.serverSsr) this.router.serverSsr.injectScript(scriptsToInject);
+	}
+	takeAll() {
+		const bufferedScripts = this._queue;
+		this._queue = [];
+		if (bufferedScripts.length === 0) return;
+		if (bufferedScripts.length === 1) return bufferedScripts[0] + ";document.currentScript.remove()";
+		return bufferedScripts.join(";") + ";document.currentScript.remove()";
+	}
+	injectBufferedScripts() {
+		if (this._cleanedUp) return;
+		if (this._queue.length === 0) return;
+		const scriptsToInject = this.takeAll();
+		if (scriptsToInject && this.router?.serverSsr) this.router.serverSsr.injectScript(scriptsToInject);
+	}
+	cleanup() {
+		this._cleanedUp = true;
+		this._queue = [];
+		this.router = void 0;
+	}
+};
+var isProd = process.env.NODE_ENV === "production";
+var MANIFEST_CACHE_SIZE = 100;
+var manifestCaches = /* @__PURE__ */ new WeakMap();
+function getManifestCache(manifest) {
+	const cache = manifestCaches.get(manifest);
+	if (cache) return cache;
+	const newCache = require_lru_cache.createLRUCache(MANIFEST_CACHE_SIZE);
+	manifestCaches.set(manifest, newCache);
+	return newCache;
+}
+function attachRouterServerSsrUtils({ router, manifest }) {
+	router.ssr = { manifest };
+	let _dehydrated = false;
+	let _serializationFinished = false;
+	const renderFinishedListeners = [];
+	const serializationFinishedListeners = [];
+	const scriptBuffer = new ScriptBuffer(router);
+	let injectedHtmlBuffer = "";
+	router.serverSsr = {
+		injectHtml: (html) => {
+			if (!html) return;
+			injectedHtmlBuffer += html;
+			router.emit({ type: "onInjectedHtml" });
+		},
+		injectScript: (script) => {
+			if (!script) return;
+			const html = `<script${router.options.ssr?.nonce ? ` nonce='${router.options.ssr.nonce}'` : ""}>${script}<\/script>`;
+			router.serverSsr.injectHtml(html);
+		},
+		dehydrate: async () => {
+			if (_dehydrated) {
+				if (process.env.NODE_ENV !== "production") throw new Error("Invariant failed: router is already dehydrated!");
+				require_invariant.invariant();
+			}
+			let matchesToDehydrate = router.stores.activeMatchesSnapshot.state;
+			if (router.isShell()) matchesToDehydrate = matchesToDehydrate.slice(0, 1);
+			const matches = matchesToDehydrate.map(dehydrateMatch);
+			let manifestToDehydrate = void 0;
+			if (manifest) {
+				const currentRouteIdsList = matchesToDehydrate.map((m) => m.routeId);
+				const manifestCacheKey = currentRouteIdsList.join("\0");
+				let filteredRoutes;
+				if (isProd) filteredRoutes = getManifestCache(manifest).get(manifestCacheKey);
+				if (!filteredRoutes) {
+					const currentRouteIds = new Set(currentRouteIdsList);
+					const nextFilteredRoutes = {};
+					for (const routeId in manifest.routes) {
+						const routeManifest = manifest.routes[routeId];
+						if (currentRouteIds.has(routeId)) nextFilteredRoutes[routeId] = routeManifest;
+						else if (routeManifest.assets && routeManifest.assets.length > 0) nextFilteredRoutes[routeId] = { assets: routeManifest.assets };
+					}
+					if (isProd) getManifestCache(manifest).set(manifestCacheKey, nextFilteredRoutes);
+					filteredRoutes = nextFilteredRoutes;
+				}
+				manifestToDehydrate = { routes: filteredRoutes };
+			}
+			const dehydratedRouter = {
+				manifest: manifestToDehydrate,
+				matches
+			};
+			const lastMatchId = matchesToDehydrate[matchesToDehydrate.length - 1]?.id;
+			if (lastMatchId) dehydratedRouter.lastMatchId = require_ssr_match_id.dehydrateSsrMatchId(lastMatchId);
+			const dehydratedData = await router.options.dehydrate?.();
+			if (dehydratedData) dehydratedRouter.dehydratedData = dehydratedData;
+			_dehydrated = true;
+			const trackPlugins = { didRun: false };
+			const serializationAdapters = router.options.serializationAdapters;
+			const plugins = serializationAdapters ? serializationAdapters.map((t) => require_transformer.makeSsrSerovalPlugin(t, trackPlugins)).concat(require_seroval_plugins.defaultSerovalPlugins) : require_seroval_plugins.defaultSerovalPlugins;
+			const signalSerializationComplete = () => {
+				_serializationFinished = true;
+				try {
+					serializationFinishedListeners.forEach((l) => l());
+					router.emit({ type: "onSerializationFinished" });
+				} catch (err) {
+					console.error("Serialization listener error:", err);
+				} finally {
+					serializationFinishedListeners.length = 0;
+					renderFinishedListeners.length = 0;
+				}
+			};
+			(0, seroval.crossSerializeStream)(dehydratedRouter, {
+				refs: /* @__PURE__ */ new Map(),
+				plugins,
+				onSerialize: (data, initial) => {
+					let serialized = initial ? TSR_PREFIX + data : data;
+					if (trackPlugins.didRun) serialized = P_PREFIX + serialized + P_SUFFIX;
+					scriptBuffer.enqueue(serialized);
+				},
+				scopeId: SCOPE_ID,
+				onDone: () => {
+					scriptBuffer.enqueue(require_constants.GLOBAL_TSR + ".e()");
+					scriptBuffer.flush();
+					signalSerializationComplete();
+				},
+				onError: (err) => {
+					console.error("Serialization error:", err);
+					signalSerializationComplete();
+				}
+			});
+		},
+		isDehydrated() {
+			return _dehydrated;
+		},
+		isSerializationFinished() {
+			return _serializationFinished;
+		},
+		onRenderFinished: (listener) => renderFinishedListeners.push(listener),
+		onSerializationFinished: (listener) => serializationFinishedListeners.push(listener),
+		setRenderFinished: () => {
+			try {
+				renderFinishedListeners.forEach((l) => l());
+			} catch (err) {
+				console.error("Error in render finished listener:", err);
+			} finally {
+				renderFinishedListeners.length = 0;
+			}
+			scriptBuffer.liftBarrier();
+		},
+		takeBufferedScripts() {
+			const scripts = scriptBuffer.takeAll();
+			return {
+				tag: "script",
+				attrs: {
+					nonce: router.options.ssr?.nonce,
+					className: "$tsr",
+					id: require_constants.TSR_SCRIPT_BARRIER_ID
+				},
+				children: scripts
+			};
+		},
+		liftScriptBarrier() {
+			scriptBuffer.liftBarrier();
+		},
+		takeBufferedHtml() {
+			if (!injectedHtmlBuffer) return;
+			const buffered = injectedHtmlBuffer;
+			injectedHtmlBuffer = "";
+			return buffered;
+		},
+		cleanup() {
+			if (!router.serverSsr) return;
+			renderFinishedListeners.length = 0;
+			serializationFinishedListeners.length = 0;
+			injectedHtmlBuffer = "";
+			scriptBuffer.cleanup();
+			router.serverSsr = void 0;
+		}
+	};
+}
+/**
+* Get the origin for the request.
+*
+* SECURITY: We intentionally do NOT trust the Origin header for determining
+* the router's origin. The Origin header can be spoofed by attackers, which
+* could lead to SSRF-like vulnerabilities where redirects are constructed
+* using a malicious origin (CVE-2024-34351).
+*
+* Instead, we derive the origin from request.url, which is typically set by
+* the server infrastructure (not client-controlled headers).
+*
+* For applications behind proxies that need to trust forwarded headers,
+* use the router's `origin` option to explicitly configure a trusted origin.
+*/
+function getOrigin(request) {
+	try {
+		return new URL(request.url).origin;
+	} catch {}
+	return "http://localhost";
+}
+function getNormalizedURL(url, base) {
+	if (typeof url === "string") url = url.replace("\\", "%5C");
+	const rawUrl = new URL(url, base);
+	const { path: decodedPathname, handledProtocolRelativeURL } = require_utils.decodePath(rawUrl.pathname);
+	const searchParams = new URLSearchParams(rawUrl.search);
+	const normalizedHref = decodedPathname + (searchParams.size > 0 ? "?" : "") + searchParams.toString() + rawUrl.hash;
+	return {
+		url: new URL(normalizedHref, rawUrl.origin),
+		handledProtocolRelativeURL
+	};
+}
+//#endregion
+exports.attachRouterServerSsrUtils = attachRouterServerSsrUtils;
+exports.getNormalizedURL = getNormalizedURL;
+exports.getOrigin = getOrigin;
+
+//# sourceMappingURL=ssr-server.cjs.map