react-router 0.0.0-experimental-bcda00aaf → 0.0.0-experimental-3278f3ca6

package/dist/lib/server-runtime/errors.d.ts

@@ -0,0 +1,51 @@
+import type { StaticHandlerContext } from "../router/router";
+import { ServerMode } from "./mode";
+/**
+ * This thing probably warrants some explanation.
+ *
+ * The whole point here is to emulate componentDidCatch for server rendering and
+ * data loading. It can get tricky. React can do this on component boundaries
+ * but doesn't support it for server rendering or data loading. We know enough
+ * with nested routes to be able to emulate the behavior (because we know them
+ * statically before rendering.)
+ *
+ * Each route can export an `ErrorBoundary`.
+ *
+ * - When rendering throws an error, the nearest error boundary will render
+ *   (normal react componentDidCatch). This will be the route's own boundary, but
+ *   if none is provided, it will bubble up to the parents.
+ * - When data loading throws an error, the nearest error boundary will render
+ * - When performing an action, the nearest error boundary for the action's
+ *   route tree will render (no redirect happens)
+ *
+ * During normal react rendering, we do nothing special, just normal
+ * componentDidCatch.
+ *
+ * For server rendering, we mutate `renderBoundaryRouteId` to know the last
+ * layout that has an error boundary that tried to render. This emulates which
+ * layout would catch a thrown error. If the rendering fails, we catch the error
+ * on the server, and go again a second time with the emulator holding on to the
+ * information it needs to render the same error boundary as a dynamically
+ * thrown render error.
+ *
+ * When data loading, server or client side, we use the emulator to likewise
+ * hang on to the error and re-render at the appropriate layout (where a thrown
+ * error would have been caught by cDC).
+ *
+ * When actions throw, it all works the same. There's an edge case to be aware
+ * of though. Actions normally are required to redirect, but in the case of
+ * errors, we render the action's route with the emulator holding on to the
+ * error. If during this render a parent route/loader throws we ignore that new
+ * error and render the action's original error as deeply as possible. In other
+ * words, we simply ignore the new error and use the action's error in place
+ * because it came first, and that just wouldn't be fair to let errors cut in
+ * line.
+ */
+export declare function sanitizeError<T = unknown>(error: T, serverMode: ServerMode): Error | T;
+export declare function sanitizeErrors(errors: NonNullable<StaticHandlerContext["errors"]>, serverMode: ServerMode): {};
+export type SerializedError = {
+    message: string;
+    stack?: string;
+};
+export declare function serializeError(error: Error, serverMode: ServerMode): SerializedError;
+export declare function serializeErrors(errors: StaticHandlerContext["errors"], serverMode: ServerMode): StaticHandlerContext["errors"];

package/dist/lib/server-runtime/formData.d.ts

@@ -0,0 +1,15 @@
+export type UploadHandlerPart = {
+    name: string;
+    filename?: string;
+    contentType: string;
+    data: AsyncIterable<Uint8Array>;
+};
+export type UploadHandler = (part: UploadHandlerPart) => Promise<File | string | null | undefined>;
+export declare function composeUploadHandlers(...handlers: UploadHandler[]): UploadHandler;
+/**
+ * Allows you to handle multipart forms (file uploads) for your app.
+ *
+ * TODO: Update this comment
+ * @see https://remix.run/utils/parse-multipart-form-data
+ */
+export declare function parseMultipartFormData(request: Request, uploadHandler: UploadHandler): Promise<FormData>;

package/dist/lib/server-runtime/headers.d.ts

@@ -0,0 +1,3 @@
+import type { ServerBuild } from "./build";
+import type { StaticHandlerContext } from "../router/router";
+export declare function getDocumentHeaders(build: ServerBuild, context: StaticHandlerContext): Headers;

package/dist/lib/server-runtime/invariant.d.ts

@@ -0,0 +1,2 @@
+export default function invariant(value: boolean, message?: string): asserts value;
+export default function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;

package/dist/lib/server-runtime/jsonify.d.ts

@@ -0,0 +1,33 @@
+export type Jsonify<T> = IsAny<T> extends true ? any : T extends {
+    toJSON(): infer U;
+} ? (U extends JsonValue ? U : unknown) : T extends JsonPrimitive ? T : T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends Promise<unknown> ? EmptyObject : T extends Map<unknown, unknown> ? EmptyObject : T extends Set<unknown> ? EmptyObject : T extends TypedArray ? Record<string, number> : T extends NotJson ? never : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [NeverToNull<Jsonify<F>>, ...Jsonify<R>] : T extends readonly unknown[] ? Array<NeverToNull<Jsonify<T[number]>>> : T extends Record<keyof unknown, unknown> ? JsonifyObject<T> : unknown extends T ? unknown : never;
+type ValueIsNotJson<T> = T extends NotJson ? true : false;
+type IsNotJson<T> = {
+    [K in keyof T]-?: ValueIsNotJson<T[K]>;
+};
+type JsonifyValues<T> = {
+    [K in keyof T]: Jsonify<T[K]>;
+};
+type JsonifyObject<T extends Record<keyof unknown, unknown>> = {
+    [K in keyof T as unknown extends T[K] ? never : IsNotJson<T>[K] extends false ? K : never]: JsonifyValues<T>[K];
+} & {
+    [K in keyof T as unknown extends T[K] ? K : IsNotJson<T>[K] extends false ? never : IsNotJson<T>[K] extends true ? never : K]?: JsonifyValues<T>[K];
+};
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonObject = {
+    [K in string]: JsonValue;
+} & {
+    [K in string]?: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type NotJson = undefined | symbol | AnyFunction;
+type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+type AnyFunction = (...args: any[]) => unknown;
+type NeverToNull<T> = [T] extends [never] ? null : T;
+declare const emptyObjectSymbol: unique symbol;
+export type EmptyObject = {
+    [emptyObjectSymbol]?: never;
+};
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export {};

package/dist/lib/server-runtime/markup.d.ts

@@ -0,0 +1 @@
+export declare function escapeHtml(html: string): string;

package/dist/lib/server-runtime/mode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The mode to use when running the server.
+ */
+export declare enum ServerMode {
+    Development = "development",
+    Production = "production",
+    Test = "test"
+}
+export declare function isServerMode(value: any): value is ServerMode;

package/dist/lib/server-runtime/responses.d.ts

@@ -0,0 +1,37 @@
+export type JsonFunction = <Data>(data: Data, init?: number | ResponseInit) => TypedResponse<Data>;
+export type TypedResponse<T = unknown> = Omit<Response, "json"> & {
+    json(): Promise<T>;
+};
+/**
+ * This is a shortcut for creating `application/json` responses. Converts `data`
+ * to JSON and sets the `Content-Type` header.
+ *
+ * @see https://remix.run/utils/json
+ */
+export declare const json: JsonFunction;
+export type RedirectFunction = (url: string, init?: number | ResponseInit) => TypedResponse<never>;
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @see https://remix.run/utils/redirect
+ */
+export declare const redirect: RedirectFunction;
+/**
+ * A redirect response that will force a document reload to the new location.
+ * Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @see https://remix.run/utils/redirect
+ */
+export declare const redirectDocument: RedirectFunction;
+/**
+ * A redirect response. Sets the status code and the `Location` header.
+ * Defaults to "302 Found".
+ *
+ * @see https://remix.run/utils/redirect
+ */
+export declare const replace: RedirectFunction;
+export declare function isResponse(value: any): value is Response;
+export declare function isRedirectStatusCode(statusCode: number): boolean;
+export declare function isRedirectResponse(response: Response): boolean;

package/dist/lib/server-runtime/routeMatching.d.ts

@@ -0,0 +1,8 @@
+import type { Params } from "../router/utils";
+import type { ServerRoute } from "./routes";
+export interface RouteMatch<Route> {
+    params: Params;
+    pathname: string;
+    route: Route;
+}
+export declare function matchServerRoutes(routes: ServerRoute[], pathname: string, basename?: string): RouteMatch<ServerRoute>[] | null;

package/dist/lib/server-runtime/routeModules.d.ts

@@ -0,0 +1,212 @@
+import type { Location } from "../router/history";
+import type { ActionFunction as RRActionFunction, ActionFunctionArgs as RRActionFunctionArgs, AgnosticRouteMatch, LoaderFunction as RRLoaderFunction, LoaderFunctionArgs as RRLoaderFunctionArgs, Params } from "../router/utils";
+import type { AppData, AppLoadContext } from "./data";
+import type { SerializeFrom } from "../dom/ssr/components";
+import type { LinkDescriptor } from "../router/links";
+export interface RouteModules<RouteModule> {
+    [routeId: string]: RouteModule | undefined;
+}
+/**
+ * @deprecated Use `LoaderFunctionArgs`/`ActionFunctionArgs` instead
+ */
+export type DataFunctionArgs = RRActionFunctionArgs<AppLoadContext> & RRLoaderFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that handles data mutations for a route on the server
+ */
+export type ActionFunction = (args: ActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `action` function
+ */
+export type ActionFunctionArgs = RRActionFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that handles data mutations for a route on the client
+ * @private Public API is exported from @react-router/react
+ */
+type ClientActionFunction = (args: ClientActionFunctionArgs) => ReturnType<RRActionFunction>;
+/**
+ * Arguments passed to a route `clientAction` function
+ * @private Public API is exported from @react-router/react
+ */
+export type ClientActionFunctionArgs = RRActionFunctionArgs<undefined> & {
+    serverAction: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+/**
+ * A function that loads data for a route on the server
+ */
+export type LoaderFunction = (args: LoaderFunctionArgs) => ReturnType<RRLoaderFunction>;
+/**
+ * Arguments passed to a route `loader` function
+ */
+export type LoaderFunctionArgs = RRLoaderFunctionArgs<AppLoadContext> & {
+    context: AppLoadContext;
+};
+/**
+ * A function that loads data for a route on the client
+ * @private Public API is exported from @react-router/react
+ */
+type ClientLoaderFunction = ((args: ClientLoaderFunctionArgs) => ReturnType<RRLoaderFunction>) & {
+    hydrate?: boolean;
+};
+/**
+ * Arguments passed to a route `clientLoader` function
+ * @private Public API is exported from @react-router/react
+ */
+export type ClientLoaderFunctionArgs = RRLoaderFunctionArgs<undefined> & {
+    serverLoader: <T = AppData>() => Promise<SerializeFrom<T>>;
+};
+export type HeadersArgs = {
+    loaderHeaders: Headers;
+    parentHeaders: Headers;
+    actionHeaders: Headers;
+    errorHeaders: Headers | undefined;
+};
+/**
+ * A function that returns HTTP headers to be used for a route. These headers
+ * will be merged with (and take precedence over) headers from parent routes.
+ */
+export interface HeadersFunction {
+    (args: HeadersArgs): Headers | HeadersInit;
+}
+/**
+ * A function that defines `<link>` tags to be inserted into the `<head>` of
+ * the document on route transitions.
+ */
+export interface LinksFunction {
+    (): LinkDescriptor[];
+}
+/**
+ * A function that returns an array of data objects to use for rendering
+ * metadata HTML tags in a route. These tags are not rendered on descendant
+ * routes in the route hierarchy. In other words, they will only be rendered on
+ * the route in which they are exported.
+ *
+ * @param Loader - The type of the current route's loader function
+ * @param MatchLoaders - Mapping from a parent route's filepath to its loader
+ * function type
+ *
+ * Note that parent route filepaths are relative to the `app/` directory.
+ *
+ * For example, if this meta function is for `/sales/customers/$customerId`:
+ *
+ * ```ts
+ * // app/root.tsx
+ * const loader = () => {
+ *  return json({ hello: "world" } as const)
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales.tsx
+ * const loader = () => {
+ *  return json({ salesCount: 1074 })
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers.tsx
+ * const loader = () => {
+ *   return json({ customerCount: 74 })
+ * }
+ * export type Loader = typeof loader
+ *
+ * // app/routes/sales/customers/$customersId.tsx
+ * import type { Loader as RootLoader } from "../../../root"
+ * import type { Loader as SalesLoader } from "../../sales"
+ * import type { Loader as CustomersLoader } from "../../sales/customers"
+ *
+ * const loader = () => {
+ *   return json({ name: "Customer name" })
+ * }
+ *
+ * const meta: MetaFunction<typeof loader, {
+ *  "root": RootLoader,
+ *  "routes/sales": SalesLoader,
+ *  "routes/sales/customers": CustomersLoader,
+ * }> = ({ data, matches }) => {
+ *   const { name } = data
+ *   //      ^? string
+ *   const { customerCount } = matches.find((match) => match.id === "routes/sales/customers").data
+ *   //      ^? number
+ *   const { salesCount } = matches.find((match) => match.id === "routes/sales").data
+ *   //      ^? number
+ *   const { hello } = matches.find((match) => match.id === "root").data
+ *   //      ^? "world"
+ * }
+ * ```
+ */
+export interface ServerRuntimeMetaFunction<Loader extends LoaderFunction | unknown = unknown, ParentsLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    (args: ServerRuntimeMetaArgs<Loader, ParentsLoaders>): ServerRuntimeMetaDescriptor[];
+}
+interface ServerRuntimeMetaMatch<RouteId extends string = string, Loader extends LoaderFunction | unknown = unknown> {
+    id: RouteId;
+    pathname: AgnosticRouteMatch["pathname"];
+    data: Loader extends LoaderFunction ? SerializeFrom<Loader> : unknown;
+    handle?: RouteHandle;
+    params: AgnosticRouteMatch["params"];
+    meta: ServerRuntimeMetaDescriptor[];
+    error?: unknown;
+}
+type ServerRuntimeMetaMatches<MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> = Array<{
+    [K in keyof MatchLoaders]: ServerRuntimeMetaMatch<Exclude<K, number | symbol>, MatchLoaders[K]>;
+}[keyof MatchLoaders]>;
+export interface ServerRuntimeMetaArgs<Loader extends LoaderFunction | unknown = unknown, MatchLoaders extends Record<string, LoaderFunction | unknown> = Record<string, unknown>> {
+    data: (Loader extends LoaderFunction ? SerializeFrom<Loader> : AppData) | undefined;
+    params: Params;
+    location: Location;
+    matches: ServerRuntimeMetaMatches<MatchLoaders>;
+    error?: unknown;
+}
+export type ServerRuntimeMetaDescriptor = {
+    charSet: "utf-8";
+} | {
+    title: string;
+} | {
+    name: string;
+    content: string;
+} | {
+    property: string;
+    content: string;
+} | {
+    httpEquiv: string;
+    content: string;
+} | {
+    "script:ld+json": LdJsonObject;
+} | {
+    tagName: "meta" | "link";
+    [name: string]: string;
+} | {
+    [name: string]: unknown;
+};
+type LdJsonObject = {
+    [Key in string]: LdJsonValue;
+} & {
+    [Key in string]?: LdJsonValue | undefined;
+};
+type LdJsonArray = LdJsonValue[] | readonly LdJsonValue[];
+type LdJsonPrimitive = string | number | boolean | null;
+type LdJsonValue = LdJsonPrimitive | LdJsonObject | LdJsonArray;
+/**
+ * An arbitrary object that is associated with a route.
+ */
+export type RouteHandle = unknown;
+export interface EntryRouteModule {
+    clientAction?: ClientActionFunction;
+    clientLoader?: ClientLoaderFunction;
+    ErrorBoundary?: any;
+    HydrateFallback?: any;
+    Layout?: any;
+    default: any;
+    handle?: RouteHandle;
+    links?: LinksFunction;
+    meta?: ServerRuntimeMetaFunction;
+}
+export interface ServerRouteModule extends EntryRouteModule {
+    action?: ActionFunction;
+    headers?: HeadersFunction | {
+        [name: string]: string;
+    };
+    loader?: LoaderFunction;
+}
+export {};

package/dist/lib/server-runtime/routes.d.ts

@@ -0,0 +1,31 @@
+import type { AgnosticDataRouteObject } from "../router/utils";
+import type { FutureConfig } from "../dom/ssr/entry";
+import type { ServerRouteModule } from "./routeModules";
+export interface RouteManifest<Route> {
+    [routeId: string]: Route;
+}
+export type ServerRouteManifest = RouteManifest<Omit<ServerRoute, "children">>;
+export interface Route {
+    index?: boolean;
+    caseSensitive?: boolean;
+    id: string;
+    parentId?: string;
+    path?: string;
+}
+export interface EntryRoute extends Route {
+    hasAction: boolean;
+    hasLoader: boolean;
+    hasClientAction: boolean;
+    hasClientLoader: boolean;
+    hasErrorBoundary: boolean;
+    imports?: string[];
+    css?: string[];
+    module: string;
+    parentId?: string;
+}
+export interface ServerRoute extends Route {
+    children: ServerRoute[];
+    module: ServerRouteModule;
+}
+export declare function createRoutes(manifest: ServerRouteManifest, parentId?: string, routesByParentId?: Record<string, Omit<ServerRoute, "children">[]>): ServerRoute[];
+export declare function createStaticHandlerDataRoutes(manifest: ServerRouteManifest, future: FutureConfig, parentId?: string, routesByParentId?: Record<string, Omit<ServerRoute, "children">[]>): AgnosticDataRouteObject[];

package/dist/lib/server-runtime/server.d.ts

@@ -0,0 +1,5 @@
+import type { AppLoadContext } from "./data";
+import type { ServerBuild } from "./build";
+export type RequestHandler = (request: Request, loadContext?: AppLoadContext) => Promise<Response>;
+export type CreateRequestHandlerFunction = (build: ServerBuild | (() => ServerBuild | Promise<ServerBuild>), mode?: string) => RequestHandler;
+export declare const createRequestHandler: CreateRequestHandlerFunction;

package/dist/lib/server-runtime/serverHandoff.d.ts

@@ -0,0 +1,11 @@
+import type { HydrationState } from "../router/router";
+import type { FutureConfig } from "../dom/ssr/entry";
+type ValidateShape<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+export declare function createServerHandoffString<T>(serverHandoff: {
+    state?: ValidateShape<T, HydrationState>;
+    criticalCss?: string;
+    basename: string | undefined;
+    future: FutureConfig;
+    isSpaMode: boolean;
+}): string;
+export {};

package/dist/lib/server-runtime/sessions/cookieStorage.d.ts

@@ -0,0 +1,19 @@
+import type { SessionStorage, SessionIdStorageStrategy, SessionData } from "../sessions";
+interface CookieSessionStorageOptions {
+    /**
+     * The Cookie used to store the session data on the client, or options used
+     * to automatically create one.
+     */
+    cookie?: SessionIdStorageStrategy["cookie"];
+}
+/**
+ * Creates and returns a SessionStorage object that stores all session data
+ * directly in the session cookie itself.
+ *
+ * This has the advantage that no database or other backend services are
+ * needed, and can help to simplify some load-balanced scenarios. However, it
+ * also has the limitation that serialized session data may not exceed the
+ * browser's maximum cookie size. Trade-offs!
+ */
+export declare function createCookieSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg }?: CookieSessionStorageOptions): SessionStorage<Data, FlashData>;
+export {};

package/dist/lib/server-runtime/sessions/memoryStorage.d.ts

@@ -0,0 +1,17 @@
+import type { SessionData, SessionStorage, SessionIdStorageStrategy } from "../sessions";
+interface MemorySessionStorageOptions {
+    /**
+     * The Cookie used to store the session id on the client, or options used
+     * to automatically create one.
+     */
+    cookie?: SessionIdStorageStrategy["cookie"];
+}
+/**
+ * Creates and returns a simple in-memory SessionStorage object, mostly useful
+ * for testing and as a reference implementation.
+ *
+ * Note: This storage does not scale beyond a single process, so it is not
+ * suitable for most production scenarios.
+ */
+export declare function createMemorySessionStorage<Data = SessionData, FlashData = Data>({ cookie }?: MemorySessionStorageOptions): SessionStorage<Data, FlashData>;
+export {};

package/dist/lib/server-runtime/sessions.d.ts

@@ -0,0 +1,140 @@
+import type { CookieParseOptions, CookieSerializeOptions } from "cookie";
+import type { Cookie, CookieOptions } from "./cookies";
+/**
+ * An object of name/value pairs to be used in the session.
+ */
+export interface SessionData {
+    [name: string]: any;
+}
+/**
+ * Session persists data across HTTP requests.
+ *
+ * @see https://remix.run/utils/sessions#session-api
+ */
+export interface Session<Data = SessionData, FlashData = Data> {
+    /**
+     * A unique identifier for this session.
+     *
+     * Note: This will be the empty string for newly created sessions and
+     * sessions that are not backed by a database (i.e. cookie-based sessions).
+     */
+    readonly id: string;
+    /**
+     * The raw data contained in this session.
+     *
+     * This is useful mostly for SessionStorage internally to access the raw
+     * session data to persist.
+     */
+    readonly data: FlashSessionData<Data, FlashData>;
+    /**
+     * Returns `true` if the session has a value for the given `name`, `false`
+     * otherwise.
+     */
+    has(name: (keyof Data | keyof FlashData) & string): boolean;
+    /**
+     * Returns the value for the given `name` in this session.
+     */
+    get<Key extends (keyof Data | keyof FlashData) & string>(name: Key): (Key extends keyof Data ? Data[Key] : undefined) | (Key extends keyof FlashData ? FlashData[Key] : undefined) | undefined;
+    /**
+     * Sets a value in the session for the given `name`.
+     */
+    set<Key extends keyof Data & string>(name: Key, value: Data[Key]): void;
+    /**
+     * Sets a value in the session that is only valid until the next `get()`.
+     * This can be useful for temporary values, like error messages.
+     */
+    flash<Key extends keyof FlashData & string>(name: Key, value: FlashData[Key]): void;
+    /**
+     * Removes a value from the session.
+     */
+    unset(name: keyof Data & string): void;
+}
+export type FlashSessionData<Data, FlashData> = Partial<Data & {
+    [Key in keyof FlashData as FlashDataKey<Key & string>]: FlashData[Key];
+}>;
+type FlashDataKey<Key extends string> = `__flash_${Key}__`;
+export type CreateSessionFunction = <Data = SessionData, FlashData = Data>(initialData?: Data, id?: string) => Session<Data, FlashData>;
+/**
+ * Creates a new Session object.
+ *
+ * Note: This function is typically not invoked directly by application code.
+ * Instead, use a `SessionStorage` object's `getSession` method.
+ *
+ * @see https://remix.run/utils/sessions#createsession
+ */
+export declare const createSession: CreateSessionFunction;
+export type IsSessionFunction = (object: any) => object is Session;
+/**
+ * Returns true if an object is a Remix session.
+ *
+ * @see https://remix.run/utils/sessions#issession
+ */
+export declare const isSession: IsSessionFunction;
+/**
+ * SessionStorage stores session data between HTTP requests and knows how to
+ * parse and create cookies.
+ *
+ * A SessionStorage creates Session objects using a `Cookie` header as input.
+ * Then, later it generates the `Set-Cookie` header to be used in the response.
+ */
+export interface SessionStorage<Data = SessionData, FlashData = Data> {
+    /**
+     * Parses a Cookie header from a HTTP request and returns the associated
+     * Session. If there is no session associated with the cookie, this will
+     * return a new Session with no data.
+     */
+    getSession: (cookieHeader?: string | null, options?: CookieParseOptions) => Promise<Session<Data, FlashData>>;
+    /**
+     * Stores all data in the Session and returns the Set-Cookie header to be
+     * used in the HTTP response.
+     */
+    commitSession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+    /**
+     * Deletes all data associated with the Session and returns the Set-Cookie
+     * header to be used in the HTTP response.
+     */
+    destroySession: (session: Session<Data, FlashData>, options?: CookieSerializeOptions) => Promise<string>;
+}
+/**
+ * SessionIdStorageStrategy is designed to allow anyone to easily build their
+ * own SessionStorage using `createSessionStorage(strategy)`.
+ *
+ * This strategy describes a common scenario where the session id is stored in
+ * a cookie but the actual session data is stored elsewhere, usually in a
+ * database or on disk. A set of create, read, update, and delete operations
+ * are provided for managing the session data.
+ */
+export interface SessionIdStorageStrategy<Data = SessionData, FlashData = Data> {
+    /**
+     * The Cookie used to store the session id, or options used to automatically
+     * create one.
+     */
+    cookie?: Cookie | (CookieOptions & {
+        name?: string;
+    });
+    /**
+     * Creates a new record with the given data and returns the session id.
+     */
+    createData: (data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<string>;
+    /**
+     * Returns data for a given session id, or `null` if there isn't any.
+     */
+    readData: (id: string) => Promise<FlashSessionData<Data, FlashData> | null>;
+    /**
+     * Updates data for the given session id.
+     */
+    updateData: (id: string, data: FlashSessionData<Data, FlashData>, expires?: Date) => Promise<void>;
+    /**
+     * Deletes data for a given session id from the data store.
+     */
+    deleteData: (id: string) => Promise<void>;
+}
+/**
+ * Creates a SessionStorage object using a SessionIdStorageStrategy.
+ *
+ * Note: This is a low-level API that should only be used if none of the
+ * existing session storage options meet your requirements.
+ */
+export declare function createSessionStorage<Data = SessionData, FlashData = Data>({ cookie: cookieArg, createData, readData, updateData, deleteData, }: SessionIdStorageStrategy<Data, FlashData>): SessionStorage<Data, FlashData>;
+export declare function warnOnceAboutSigningSessionCookie(cookie: Cookie): void;
+export {};

package/dist/lib/server-runtime/single-fetch.d.ts

@@ -0,0 +1,30 @@
+import type { StaticHandler } from "../router/router";
+import type { DataStrategyFunction } from "../router/utils";
+import type { SingleFetchRedirectResult, SingleFetchResult, SingleFetchResults } from "../dom/ssr/single-fetch";
+import { SingleFetchRedirectSymbol } from "../dom/ssr/single-fetch";
+import type { AppLoadContext } from "./data";
+import { ServerMode } from "./mode";
+import type { ServerBuild } from "./build";
+export type { SingleFetchResult, SingleFetchResults };
+export { SingleFetchRedirectSymbol };
+export declare const SINGLE_FETCH_REDIRECT_STATUS = 202;
+export declare function getSingleFetchDataStrategy({ isActionDataRequest, loadRouteIds, }?: {
+    isActionDataRequest?: boolean;
+    loadRouteIds?: string[];
+}): DataStrategyFunction;
+export declare function singleFetchAction(build: ServerBuild, serverMode: ServerMode, staticHandler: StaticHandler, request: Request, handlerUrl: URL, loadContext: AppLoadContext, handleError: (err: unknown) => void): Promise<{
+    result: SingleFetchResult;
+    headers: Headers;
+    status: number;
+}>;
+export declare function singleFetchLoaders(build: ServerBuild, serverMode: ServerMode, staticHandler: StaticHandler, request: Request, handlerUrl: URL, loadContext: AppLoadContext, handleError: (err: unknown) => void): Promise<{
+    result: SingleFetchResults;
+    headers: Headers;
+    status: number;
+}>;
+export declare function getSingleFetchRedirect(status: number, headers: Headers, basename: string | undefined): SingleFetchRedirectResult;
+type Serializable = undefined | null | boolean | string | symbol | number | Array<Serializable> | {
+    [key: PropertyKey]: Serializable;
+} | bigint | Date | URL | RegExp | Error | Map<Serializable, Serializable> | Set<Serializable> | Promise<Serializable>;
+export declare function data(value: Serializable, init?: number | ResponseInit): import("../router/utils").DataWithResponseInit<Serializable>;
+export declare function encodeViaTurboStream(data: any, requestSignal: AbortSignal, streamTimeout: number | undefined, serverMode: ServerMode): ReadableStream<Uint8Array>;

package/dist/lib/server-runtime/typecheck.d.ts

@@ -0,0 +1,4 @@
+export declare function expectType<T>(_expression: T): void;
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+export type Expect<T extends true> = T;
+export type MutualExtends<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;

package/dist/lib/server-runtime/upload/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class MaxPartSizeExceededError extends Error {
+    field: string;
+    maxBytes: number;
+    constructor(field: string, maxBytes: number);
+}