@storybook/tanstack-react 0.0.0-pr-34403-sha-14169208 → 10.4.0-alpha.17

package/dist/_browser-chunks/{chunk-SXO3DKIN.js → chunk-73EPJ7AY.js}

@@ -7,6 +7,7 @@ var preview_exports = {};
 __export(preview_exports, {
   applyDecorators: () => applyDecorators,
   loaders: () => loaders,
+  optimizeDeps: () => optimizeDeps,
   parameters: () => parameters
 });
 import { applyDecorators as reactApplyDecorators } from "@storybook/react/entry-preview-docs";
@@ -18,9 +19,7 @@ import {
   createRootRoute,
   createRoute as createRoute2,
   createRouter,
-  Route,
   RouterProvider,
-  RootRoute as RootRoute2,
   interpolatePath,
   defaultStringifySearch
 } from "@tanstack/react-router";
@@ -99,13 +98,58 @@ function resolveStoryLeaf(tree, { path, boundRouteId }) {
   return firstChild || root;
 }
 
+// src/routing/utils.ts
+import { Route, RootRoute as RootRoute2 } from "@tanstack/react-router";
+function isRoute(value) {
+  return value instanceof Route || value instanceof RootRoute2;
+}
+
 // src/routing/decorator.tsx
 var StoryContext = React.createContext({ Story: () => null }), StoryFromContext = () => {
   let { Story } = React.useContext(StoryContext);
   return React.createElement(Story, null);
-};
-function isRoute(value) {
-  return value instanceof Route || value instanceof RootRoute2;
+}, tanstackRouteDecorator = (Story, context) => React.createElement(TanStackRouterStory, { Story, context });
+function TanStackRouterStory({ Story, context }) {
+  let routerContext = context.parameters.tanstack?.router?.useRouterContext?.({
+    storyContext: context
+  }), router = React.useMemo(
+    () => createStoryRouter({ Story: StoryFromContext, context, routerContext }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [context.id]
+  ), providerContext = React.useMemo(
+    () => ({
+      ...context.parameters.tanstack?.router?.context,
+      ...routerContext
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [context.id, routerContext]
+  );
+  return React.createElement(StoryContext.Provider, { value: { Story } }, React.createElement(RouterProvider, { router, context: providerContext }));
+}
+function createStoryRouter({
+  Story,
+  context,
+  routerContext
+}) {
+  let routerParameters = context.parameters.tanstack?.router ?? {}, { tree, leaf } = resolveTree(Story, context), routeTree = tree.root, inferredPath = routerParameters?.path || leaf.fullPath || routeTree.children?.[0]?.fullPath || "/", resolvedPath = interpolatePath({
+    path: inferredPath,
+    params: routerParameters?.params ?? {}
+  }).interpolatedPath, search = routerParameters?.query ? defaultStringifySearch(routerParameters.query) : "";
+  search && (resolvedPath += search);
+  let history = createMemoryHistory({
+    initialEntries: [resolvedPath]
+  });
+  return history.replace(resolvedPath), createRouter({
+    routeTree,
+    history,
+    defaultNotFoundComponent(props) {
+      return React.createElement("div", null, "Route not found: ", props.routeId);
+    },
+    defaultErrorComponent({ error }) {
+      return React.createElement("div", null, "Story did something wrong : ", String(error));
+    },
+    context: routerContext
+  });
 }
 function injectStoryComponent(leaf, Story, overrides, leafId) {
   let userOverride = overrides?.[leafId];
@@ -141,55 +185,9 @@ function resolveTree(Story, context) {
     leaf: syntheticChild
   };
 }
-function createStoryRouter({
-  Story,
-  context,
-  routerContext
-}) {
-  let routerParameters = context.parameters.tanstack?.router ?? {}, { tree, leaf } = resolveTree(Story, context), routeTree = tree.root, inferredPath = routerParameters?.path || leaf.fullPath || routeTree.children?.[0]?.fullPath || "/", resolvedPath = interpolatePath({
-    path: inferredPath,
-    params: routerParameters?.params ?? {}
-  }).interpolatedPath, search = routerParameters?.query ? defaultStringifySearch(routerParameters.query) : "";
-  search && (resolvedPath += search);
-  let history = createMemoryHistory({
-    initialEntries: [resolvedPath]
-  });
-  return history.replace(resolvedPath), createRouter({
-    routeTree,
-    history,
-    defaultNotFoundComponent(props) {
-      return React.createElement("div", null, "Route not found: ", props.routeId);
-    },
-    defaultErrorComponent({ error }) {
-      return React.createElement("div", null, "Story did something wrong : ", String(error));
-    },
-    context: routerContext
-  });
-}
-var tanstackRouteDecorator = (Story, context) => React.createElement(TanStackRouterStory, { Story, context });
-function TanStackRouterStory({ Story, context }) {
-  let routerContext = context.parameters.tanstack?.router?.useRouterContext?.({
-    storyContext: context
-  }), router = React.useMemo(
-    () => createStoryRouter({ Story: StoryFromContext, context, routerContext }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [context.id]
-  ), providerContext = React.useMemo(
-    () => ({
-      ...context.parameters.tanstack?.router?.context,
-      ...routerContext
-    }),
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [context.id, routerContext]
-  );
-  return React.createElement(StoryContext.Provider, { value: { Story } }, React.createElement(RouterProvider, { router, context: providerContext }));
-}
 
 // src/routing/loader.ts
-import { Route as Route2, RootRoute as RootRoute3 } from "@tanstack/react-router";
-function isRoute2(value) {
-  return value instanceof Route2 || value instanceof RootRoute3;
-}
+import { RootRoute as RootRoute3 } from "@tanstack/react-router";
 function getComponentFromRoute(route) {
   if (route.options?.component)
     return route.options.component;
@@ -197,30 +195,36 @@ function getComponentFromRoute(route) {
     return route.children?.[0]?.options?.component;
 }
 var routeComponentLoader = (context) => {
-  let componentRoute = isRoute2(context.component) ? context.component : void 0, routerParameters = context.parameters.tanstack?.router ?? {}, resolvedRoute = (isRoute2(routerParameters.route) ? routerParameters.route : void 0) ?? componentRoute;
-  if (resolvedRoute) {
+  let routerParameters = context.parameters.tanstack?.router ?? {}, parameterRoute = isRoute(routerParameters.route) ? routerParameters.route : void 0;
+  if (parameterRoute) {
     if (!context.component) {
-      let component = getComponentFromRoute(resolvedRoute);
-      component && (componentRoute || !context.component) && (context.component = component);
+      let component = getComponentFromRoute(parameterRoute);
+      component && !context.component && (context.component = component);
     }
-    context.route || (context.route = resolvedRoute);
+    context.route || (context.route = parameterRoute);
   }
 };
 
 // src/preview.tsx
 var loaders = [routeComponentLoader], applyDecorators = (storyFn, allDecorators) => (
   // reorder decorators so `jsxDecorator` is innermost, and `tanstackRouteDecorator` is just outside it
+  // There is an issue if `tanstackRouteDecorator` is innermost. All stories crashes due to a bug with the jsxDecorator.
   reactApplyDecorators(storyFn, [
     tanstackRouteDecorator,
     ...allDecorators
   ])
 ), parameters = {
   tanstack: {}
-};
+}, optimizeDeps = [
+  "@tanstack/react-devtools",
+  "@tanstack/react-query-devtools",
+  "@tanstack/react-router-devtools"
+];
 
 export {
   loaders,
   applyDecorators,
   parameters,
+  optimizeDeps,
   preview_exports
 };

package/dist/export-mocks/start.d.ts

@@ -3,6 +3,99 @@ import { createServerFn as createServerFn$1 } from '@tanstack/start-client-core'
 export * from '@tanstack/start-client-core';
 export * from '@tanstack/react-start';
 
+type RequestOptions<TRegister = unknown> = {
+    context?: TRegister extends {
+        server: {
+            requestContext: infer TRequestContext;
+        };
+    } ? TRequestContext : unknown;
+};
+type MockRequestExecutor<TRegister = unknown> = (request: Request, opts?: RequestOptions<TRegister>) => Promise<unknown> | unknown;
+type HandlerContext = {
+    request: Request;
+    responseHeaders: Headers;
+    router?: unknown;
+    context?: unknown;
+    requestContext?: unknown;
+};
+type HandlerCallback<TRouter = unknown> = (context: HandlerContext & {
+    router?: TRouter;
+}) => Promise<unknown> | unknown;
+type SessionConfig = Record<string, unknown>;
+type MockSession<TSessionData extends Record<string, unknown> = Record<string, unknown>> = {
+    data: Partial<TSessionData>;
+    update: (update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
+    save: () => Promise<void>;
+    clear: () => Promise<void>;
+};
+declare const HEADERS: {
+    readonly TSS_SHELL: "X-TSS_SHELL";
+};
+declare const VIRTUAL_MODULES: {
+    readonly startManifest: "tanstack-start-manifest:v";
+    readonly injectedHeadScripts: "tanstack-start-injected-head-scripts:v";
+    readonly serverFnResolver: "#tanstack-start-server-fn-resolver";
+};
+declare function StartServer(): null;
+declare const defineHandlerCallback: <TRouter = unknown>(handler: HandlerCallback<TRouter>) => HandlerCallback<TRouter>;
+declare const defaultStreamHandler: () => Promise<Response>;
+declare const defaultRenderHandler: () => Promise<Response>;
+declare const requestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister>) => Promise<Response>;
+declare const createRequestHandler: <TRegister = unknown>(handler: MockRequestExecutor<TRegister>) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
+declare const createStartHandler: <TRegister = unknown>(cbOrOptions: HandlerCallback | {
+    handler?: HandlerCallback;
+}) => (request: Request, requestOpts?: RequestOptions<TRegister> | undefined) => Promise<Response>;
+declare const attachRouterServerSsrUtils: <TRouter>(router: TRouter) => TRouter;
+declare const transformReadableStreamWithRouter: <TReadableStream>(stream: TReadableStream) => TReadableStream;
+declare const transformPipeableStreamWithRouter: <TPipeableStream>(stream: TPipeableStream) => TPipeableStream;
+declare const getRequest: () => Request;
+declare const getRequestHeaders: () => Headers;
+declare const getRequestHeader: (name: string) => string | undefined;
+declare const getRequestIP: (opts?: {
+    xForwardedFor?: boolean;
+}) => string | undefined;
+declare const getRequestHost: (opts?: {
+    xForwardedHost?: boolean;
+}) => string;
+declare const getRequestUrl: (opts?: {
+    xForwardedHost?: boolean;
+    xForwardedProto?: boolean;
+}) => URL;
+declare const getRequestProtocol: (opts?: {
+    xForwardedProto?: boolean;
+}) => string;
+declare const setResponseHeaders: (headers: HeadersInit) => void;
+declare const getResponseHeaders: () => Headers;
+declare const getResponseHeader: (name: string) => string | undefined;
+declare const setResponseHeader: (name: string, value: string | Array<string>) => void;
+declare const removeResponseHeader: (name: string) => void;
+declare const clearResponseHeaders: (headerNames?: Array<string>) => void;
+declare const getResponseStatus: () => number;
+declare const setResponseStatus: (code?: number, text?: string) => void;
+declare const getCookies: () => {
+    [k: string]: string;
+};
+declare const getCookie: (name: string) => string | undefined;
+declare const setCookie: (name: string, value: string, options?: Record<string, unknown>) => void;
+declare const deleteCookie: (name: string, options?: Record<string, unknown>) => void;
+declare const useSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
+declare const getSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig) => Promise<MockSession<TSessionData>>;
+declare const updateSession: <TSessionData extends Record<string, unknown> = Record<string, unknown>>(_config: SessionConfig, update?: Partial<TSessionData> | ((prev: Partial<TSessionData>) => Partial<TSessionData>)) => Promise<MockSession<TSessionData>>;
+declare const sealSession: (_config: SessionConfig) => Promise<string>;
+declare const unsealSession: (_config: SessionConfig, sealed: string) => Promise<any>;
+declare const clearSession: (_config: Partial<SessionConfig>) => Promise<void>;
+declare const getResponse: () => {
+    status: number | undefined;
+    statusText: string | undefined;
+    readonly headers: Headers;
+};
+declare const getValidatedQuery: (schema: {
+    parse?: (value: Record<string, string>) => unknown;
+    safeParse?: (value: Record<string, string>) => unknown;
+    ["~standard"]?: {
+        validate?: (value: Record<string, string>) => Promise<unknown> | unknown;
+    };
+}) => Promise<unknown>;
 declare function useServerFn<T extends (...args: Array<any>) => Promise<any>>(serverFn: T): (...args: Parameters<T>) => ReturnType<T>;
 declare const createServerFn: typeof createServerFn$1;
 declare const Link: ({ to, children, ...props }: {
@@ -17,9 +110,6 @@ declare const Navigate: ({ to }: {
 }) => null;
 declare const notFound: () => never;
 declare const createStart: () => {};
-declare const setCookie: (name: string, value: string) => void;
-declare const getCookie: (name: string) => string | undefined;
-declare const deleteCookie: (name: string) => void;
 declare const clearCookieStore: () => void;
 declare const fetchHandler: () => Promise<Response>;
 
@@ -27,4 +117,4 @@ declare const _default: {
     fetch: () => Promise<Response>;
 };
 
-export { Link, Navigate, clearCookieStore, createServerFn, createStart, _default as default, deleteCookie, fetchHandler as fetch, getCookie, notFound, setCookie, useServerFn };
+export { HEADERS, Link, Navigate, StartServer, VIRTUAL_MODULES, attachRouterServerSsrUtils, clearCookieStore, clearResponseHeaders, clearSession, createRequestHandler, createServerFn, createStart, createStartHandler, _default as default, defaultRenderHandler, defaultStreamHandler, defineHandlerCallback, deleteCookie, fetchHandler as fetch, getCookie, getCookies, getRequest, getRequestHeader, getRequestHeaders, getRequestHost, getRequestIP, getRequestProtocol, getRequestUrl, getResponse, getResponseHeader, getResponseHeaders, getResponseStatus, getSession, getValidatedQuery, notFound, removeResponseHeader, requestHandler, sealSession, setCookie, setResponseHeader, setResponseHeaders, setResponseStatus, transformPipeableStreamWithRouter, transformReadableStreamWithRouter, unsealSession, updateSession, useServerFn, useSession };

package/dist/export-mocks/start.js

@@ -8,6 +8,252 @@ import React from "react";
 import { fn } from "storybook/test";
 export * from "@tanstack/start-client-core";
 export * from "@tanstack/react-start";
+var START_SERVER_STATE_SYMBOL = Symbol.for("storybook.tanstack-react.start-server.state"), browserGlobals = globalThis, HEADERS = {
+  TSS_SHELL: "X-TSS_SHELL"
+}, VIRTUAL_MODULES = {
+  startManifest: "tanstack-start-manifest:v",
+  injectedHeadScripts: "tanstack-start-injected-head-scripts:v",
+  serverFnResolver: "#tanstack-start-server-fn-resolver"
+};
+function createNamedMock(name, implementation) {
+  return fn(implementation).mockName(`@tanstack/react-start/server::${name}`);
+}
+function createDefaultRequest() {
+  return new Request("http://localhost/");
+}
+function parseCookieHeader(cookieHeader) {
+  let cookies = /* @__PURE__ */ new Map();
+  if (!cookieHeader)
+    return cookies;
+  for (let segment of cookieHeader.split(";")) {
+    let [rawName, ...rawValue] = segment.trim().split("=");
+    rawName && cookies.set(rawName, decodeURIComponent(rawValue.join("=")));
+  }
+  return cookies;
+}
+function serializeCookie(name, value, options) {
+  let parts = [`${name}=${encodeURIComponent(value)}`];
+  return typeof options?.path == "string" && parts.push(`Path=${options.path}`), typeof options?.domain == "string" && parts.push(`Domain=${options.domain}`), typeof options?.maxAge == "number" && parts.push(`Max-Age=${options.maxAge}`), options?.expires instanceof Date && parts.push(`Expires=${options.expires.toUTCString()}`), options?.httpOnly && parts.push("HttpOnly"), options?.secure && parts.push("Secure"), typeof options?.sameSite == "string" && parts.push(`SameSite=${options.sameSite}`), parts.join("; ");
+}
+function createMockState(request = createDefaultRequest()) {
+  return {
+    request,
+    responseHeaders: new Headers(),
+    responseStatus: void 0,
+    cookies: parseCookieHeader(request.headers.get("cookie")),
+    sessionData: {}
+  };
+}
+function getState() {
+  let existingState = browserGlobals[START_SERVER_STATE_SYMBOL];
+  if (existingState)
+    return existingState;
+  let nextState = createMockState();
+  return browserGlobals[START_SERVER_STATE_SYMBOL] = nextState, nextState;
+}
+async function withRequestState(request, run) {
+  let previousState = browserGlobals[START_SERVER_STATE_SYMBOL];
+  browserGlobals[START_SERVER_STATE_SYMBOL] = createMockState(request);
+  try {
+    return await run();
+  } finally {
+    previousState ? browserGlobals[START_SERVER_STATE_SYMBOL] = previousState : delete browserGlobals[START_SERVER_STATE_SYMBOL];
+  }
+}
+function mergeResponseState(response) {
+  let state = getState(), headers = new Headers(response.headers);
+  return state.responseHeaders.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie") {
+      headers.append(key, value);
+      return;
+    }
+    headers.set(key, value);
+  }), new Response(response.body, {
+    status: state.responseStatus?.code ?? response.status,
+    statusText: state.responseStatus?.text ?? response.statusText,
+    headers
+  });
+}
+function toResponse(result) {
+  return result instanceof Response ? mergeResponseState(result) : result == null ? mergeResponseState(new Response(null)) : mergeResponseState(typeof result == "string" ? new Response(result) : new Response(JSON.stringify(result), {
+    headers: { "content-type": "application/json" }
+  }));
+}
+function getSessionRecord() {
+  let state = getState();
+  return {
+    data: state.sessionData,
+    update: async (update) => {
+      let nextValue = typeof update == "function" ? update(state.sessionData) : update;
+      return state.sessionData = {
+        ...state.sessionData,
+        ...nextValue
+      }, getSessionRecord();
+    },
+    save: async () => {
+    },
+    clear: async () => {
+      state.sessionData = {};
+    }
+  };
+}
+function StartServer() {
+  return null;
+}
+var defineHandlerCallback = createNamedMock(
+  "defineHandlerCallback",
+  (handler) => handler
+), defaultStreamHandler = createNamedMock(
+  "defaultStreamHandler",
+  async () => new Response("Storybook Mock", { status: 200 })
+), defaultRenderHandler = createNamedMock(
+  "defaultRenderHandler",
+  async () => new Response("Storybook Mock", { status: 200 })
+), requestHandler = createNamedMock(
+  "requestHandler",
+  (handler) => async (request, requestOpts) => withRequestState(request, async () => toResponse(await handler(request, requestOpts)))
+), createRequestHandler = createNamedMock(
+  "createRequestHandler",
+  (handler) => requestHandler(handler)
+), createStartHandler = createNamedMock(
+  "createStartHandler",
+  (cbOrOptions) => {
+    let handler = typeof cbOrOptions == "function" ? cbOrOptions : cbOrOptions?.handler;
+    return requestHandler(async (request, requestOpts) => handler ? handler({
+      request,
+      responseHeaders: getState().responseHeaders,
+      router: browserGlobals.__TSR_ROUTER__,
+      context: requestOpts?.context,
+      requestContext: requestOpts?.context
+    }) : new Response("Storybook Mock", { status: 200 }));
+  }
+), attachRouterServerSsrUtils = createNamedMock(
+  "attachRouterServerSsrUtils",
+  (router) => router
+), transformReadableStreamWithRouter = createNamedMock(
+  "transformReadableStreamWithRouter",
+  (stream) => stream
+), transformPipeableStreamWithRouter = createNamedMock(
+  "transformPipeableStreamWithRouter",
+  (stream) => stream
+), getRequest = createNamedMock("getRequest", () => getState().request), getRequestHeaders = createNamedMock(
+  "getRequestHeaders",
+  () => getState().request.headers
+), getRequestHeader = createNamedMock("getRequestHeader", (name) => getState().request.headers.get(name) ?? void 0), getRequestIP = createNamedMock(
+  "getRequestIP",
+  (opts) => {
+    if (opts?.xForwardedFor)
+      return getRequestHeader("x-forwarded-for")?.split(",")[0]?.trim();
+  }
+), getRequestHost = createNamedMock(
+  "getRequestHost",
+  (opts) => (opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : getRequestHeader("host")) ?? new URL(getState().request.url).host ?? "localhost"
+), getRequestUrl = createNamedMock(
+  "getRequestUrl",
+  (opts) => {
+    let url = new URL(getState().request.url), forwardedHost = opts?.xForwardedHost ? getRequestHeader("x-forwarded-host") : void 0, forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
+    return forwardedHost && (url.host = forwardedHost), forwardedProto && (url.protocol = `${forwardedProto}:`), url;
+  }
+), getRequestProtocol = createNamedMock(
+  "getRequestProtocol",
+  (opts) => {
+    let forwardedProto = opts?.xForwardedProto === !1 ? void 0 : getRequestHeader("x-forwarded-proto");
+    return forwardedProto || getRequestUrl().protocol.replace(/:$/, "") || "http";
+  }
+), setResponseHeaders = createNamedMock("setResponseHeaders", (headers) => {
+  getState().responseHeaders = new Headers(headers);
+}), getResponseHeaders = createNamedMock(
+  "getResponseHeaders",
+  () => getState().responseHeaders
+), getResponseHeader = createNamedMock("getResponseHeader", (name) => getState().responseHeaders.get(name) ?? void 0), setResponseHeader = createNamedMock(
+  "setResponseHeader",
+  (name, value) => {
+    let headers = getState().responseHeaders;
+    if (headers.delete(name), Array.isArray(value)) {
+      value.forEach((entry) => headers.append(name, entry));
+      return;
+    }
+    headers.set(name, value);
+  }
+), removeResponseHeader = createNamedMock("removeResponseHeader", (name) => {
+  getState().responseHeaders.delete(name);
+}), clearResponseHeaders = createNamedMock(
+  "clearResponseHeaders",
+  (headerNames) => {
+    if (!headerNames?.length) {
+      getState().responseHeaders = new Headers();
+      return;
+    }
+    headerNames.forEach((name) => getState().responseHeaders.delete(name));
+  }
+), getResponseStatus = createNamedMock("getResponseStatus", () => getState().responseStatus?.code ?? 200), setResponseStatus = createNamedMock(
+  "setResponseStatus",
+  (code, text) => {
+    getState().responseStatus = {
+      code,
+      text
+    };
+  }
+), getCookies = createNamedMock("getCookies", () => Object.fromEntries(getState().cookies)), getCookie = createNamedMock("getCookie", (name) => getState().cookies.get(name)), setCookie = createNamedMock(
+  "setCookie",
+  (name, value, options) => {
+    let state = getState();
+    state.cookies.set(name, value), state.responseHeaders.append("set-cookie", serializeCookie(name, value, options));
+  }
+), deleteCookie = createNamedMock(
+  "deleteCookie",
+  (name, options) => {
+    let state = getState();
+    state.cookies.delete(name), state.responseHeaders.append(
+      "set-cookie",
+      serializeCookie(name, "", {
+        ...options,
+        maxAge: 0
+      })
+    );
+  }
+), useSession = createNamedMock(
+  "useSession",
+  async (_config) => getSessionRecord()
+), getSession = createNamedMock(
+  "getSession",
+  async (_config) => getSessionRecord()
+), updateSession = createNamedMock(
+  "updateSession",
+  async (_config, update) => getSessionRecord().update(update)
+), sealSession = createNamedMock("sealSession", async (_config) => JSON.stringify(getState().sessionData)), unsealSession = createNamedMock(
+  "unsealSession",
+  async (_config, sealed) => {
+    try {
+      return JSON.parse(sealed);
+    } catch {
+      return {};
+    }
+  }
+), clearSession = createNamedMock(
+  "clearSession",
+  async (_config) => {
+    getState().sessionData = {};
+  }
+), getResponse = createNamedMock("getResponse", () => ({
+  status: getState().responseStatus?.code,
+  statusText: getState().responseStatus?.text,
+  get headers() {
+    return getState().responseHeaders;
+  }
+})), getValidatedQuery = createNamedMock(
+  "getValidatedQuery",
+  async (schema) => {
+    let query = Object.fromEntries(getRequestUrl().searchParams.entries());
+    if (typeof schema?.parse == "function")
+      return schema.parse(query);
+    if (typeof schema?.safeParse == "function") {
+      let result = await schema.safeParse(query);
+      return result && typeof result == "object" && "data" in result ? result.data : result;
+    }
+    return typeof schema?.["~standard"]?.validate == "function" ? schema["~standard"].validate(query) : query;
+  }
+);
 function useServerFn(serverFn) {
   return React.useCallback(
     (...args) => serverFn(...args),
@@ -32,25 +278,57 @@ var createServerFn = (options) => {
   onNavigate({ to });
 }, [to]), null), notFound = () => {
   throw new Error("Not found");
-}, createStart = () => ({}), cookieStore = /* @__PURE__ */ new Map(), setCookie = (name, value) => {
-  cookieStore.set(name, value);
-}, getCookie = (name) => cookieStore.get(name), deleteCookie = (name) => {
-  cookieStore.delete(name);
-}, clearCookieStore = () => {
-  cookieStore.clear();
+}, createStart = () => ({}), clientCookieStore = /* @__PURE__ */ new Map(), clearCookieStore = () => {
+  clientCookieStore.clear();
 }, fetchHandler = async () => new Response("Storybook Mock", { status: 200 });
 var start_default = { fetch: fetchHandler };
 export {
+  HEADERS,
   Link,
   Navigate,
+  StartServer,
+  VIRTUAL_MODULES,
+  attachRouterServerSsrUtils,
   clearCookieStore,
+  clearResponseHeaders,
+  clearSession,
+  createRequestHandler,
   createServerFn,
   createStart,
+  createStartHandler,
   start_default as default,
+  defaultRenderHandler,
+  defaultStreamHandler,
+  defineHandlerCallback,
   deleteCookie,
   fetchHandler as fetch,
   getCookie,
+  getCookies,
+  getRequest,
+  getRequestHeader,
+  getRequestHeaders,
+  getRequestHost,
+  getRequestIP,
+  getRequestProtocol,
+  getRequestUrl,
+  getResponse,
+  getResponseHeader,
+  getResponseHeaders,
+  getResponseStatus,
+  getSession,
+  getValidatedQuery,
   notFound,
+  removeResponseHeader,
+  requestHandler,
+  sealSession,
   setCookie,
-  useServerFn
+  setResponseHeader,
+  setResponseHeaders,
+  setResponseStatus,
+  transformPipeableStreamWithRouter,
+  transformReadableStreamWithRouter,
+  unsealSession,
+  updateSession,
+  useServerFn,
+  useSession
 };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   preview_exports
-} from "./_browser-chunks/chunk-SXO3DKIN.js";
+} from "./_browser-chunks/chunk-73EPJ7AY.js";
 import "./_browser-chunks/chunk-4BE7D4DS.js";
 
 // src/index.ts

package/dist/node/index.js

@@ -1,15 +1,14 @@
-import CJS_COMPAT_NODE_URL_a8cudokul7s from 'node:url';
-import CJS_COMPAT_NODE_PATH_a8cudokul7s from 'node:path';
-import CJS_COMPAT_NODE_MODULE_a8cudokul7s from "node:module";
+import CJS_COMPAT_NODE_URL_fmhd7e5wemi from 'node:url';
+import CJS_COMPAT_NODE_PATH_fmhd7e5wemi from 'node:path';
+import CJS_COMPAT_NODE_MODULE_fmhd7e5wemi from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_a8cudokul7s.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_a8cudokul7s.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_a8cudokul7s.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_fmhd7e5wemi.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_fmhd7e5wemi.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_fmhd7e5wemi.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Storybook's esbuild configuration
 // ------------------------------------------------------------
-import "../_node-chunks/chunk-CUC3UGKZ.js";
 
 // src/node/index.ts
 function defineMain(config) {