@flightdev/core 0.6.7

package/dist/rsc/context.d.ts

@@ -0,0 +1,201 @@
+/**
+ * @flightdev/core - Server Context
+ *
+ * API de contexto para Server Components.
+ * Provee acceso a datos del request de forma explícita y type-safe.
+ *
+ * Filosofía Flight:
+ * - Contexto EXPLÍCITO (no magia con AsyncLocalStorage)
+ * - Pasado como argumento (testeable, predecible)
+ * - Extensible con adapters custom
+ * - Inmutable por defecto
+ *
+ * @module @flightdev/core/rsc/context
+ */
+/**
+ * Contexto del servidor disponible en Server Components
+ */
+interface ServerContext {
+    /** Request actual (Web API Request) */
+    readonly request: Request;
+    /** Parámetros de ruta */
+    readonly params: Readonly<Record<string, string>>;
+    /** Search params de la URL */
+    readonly searchParams: URLSearchParams;
+    /** Headers del request */
+    readonly headers: Headers;
+    /** Accessor de cookies */
+    readonly cookies: CookieAccessor;
+    /** Headers de respuesta (mutables) */
+    readonly responseHeaders: Headers;
+    /** Signal para cancelación */
+    readonly signal: AbortSignal;
+    /** URL parseada */
+    readonly url: URL;
+    /** Método HTTP */
+    readonly method: string;
+    /** Context extensions (para adapters) */
+    readonly extensions: ContextExtensions;
+}
+/**
+ * Accessor para cookies con lazy parsing
+ */
+interface CookieAccessor {
+    /** Obtiene el valor de una cookie */
+    get(name: string): string | undefined;
+    /** Obtiene todas las cookies */
+    getAll(): Readonly<Record<string, string>>;
+    /** Verifica si existe una cookie */
+    has(name: string): boolean;
+}
+/**
+ * Extensiones del contexto para adapters
+ */
+interface ContextExtensions {
+    /** Obtiene una extensión */
+    get<T>(key: string): T | undefined;
+    /** Verifica si existe una extensión */
+    has(key: string): boolean;
+}
+/**
+ * Opciones para crear ServerContext
+ */
+interface ServerContextOptions {
+    /** Parámetros de ruta */
+    params?: Record<string, string>;
+    /** Extensiones custom */
+    extensions?: Record<string, unknown>;
+    /** Headers de respuesta iniciales */
+    responseHeaders?: HeadersInit;
+}
+/**
+ * Crea un ServerContext a partir de un Request
+ *
+ * @example
+ * ```typescript
+ * const ctx = createServerContext(request, {
+ *   params: { id: '123' }
+ * });
+ *
+ * // En un Server Component
+ * async function UserPage(props, ctx: ServerContext) {
+ *   const userId = ctx.params.id;
+ *   const user = await db.users.get(userId);
+ *   return <UserProfile user={user} />;
+ * }
+ * ```
+ */
+declare function createServerContext(request: Request, options?: ServerContextOptions): ServerContext;
+/**
+ * Obtiene un header del request
+ */
+declare function getHeader(ctx: ServerContext, name: string): string | null;
+/**
+ * Obtiene todos los headers como objeto
+ */
+declare function getHeaders(ctx: ServerContext): Record<string, string>;
+/**
+ * Verifica si el request es un POST/PUT/PATCH/DELETE (mutation request)
+ */
+declare function isMutationRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request acepta JSON
+ */
+declare function acceptsJson(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request es AJAX/fetch
+ */
+declare function isAjaxRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el request viene de un bot
+ */
+declare function isBotRequest(ctx: ServerContext): boolean;
+/**
+ * Verifica si el cliente soporta streaming
+ */
+declare function supportsStreaming(ctx: ServerContext): boolean;
+/**
+ * Obtiene el idioma preferido del cliente
+ */
+declare function getPreferredLanguage(ctx: ServerContext, available: string[]): string | undefined;
+/**
+ * Sets a cookie in the response
+ */
+declare function setCookie(ctx: ServerContext, name: string, value: string, options?: CookieOptions): void;
+/**
+ * Deletes a cookie
+ */
+declare function deleteCookie(ctx: ServerContext, name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): void;
+/**
+ * Cookie options
+ */
+interface CookieOptions {
+    /** Max age in seconds */
+    maxAge?: number;
+    /** Expiration date */
+    expires?: Date;
+    /** Cookie path */
+    path?: string;
+    /** Cookie domain */
+    domain?: string;
+    /** HTTPS only */
+    secure?: boolean;
+    /** Not accessible via JavaScript */
+    httpOnly?: boolean;
+    /** SameSite attribute */
+    sameSite?: 'Strict' | 'Lax' | 'None';
+}
+/**
+ * Sets cache control headers
+ */
+declare function setCacheControl(ctx: ServerContext, options: CacheControlOptions): void;
+/**
+ * Cache control options
+ */
+interface CacheControlOptions {
+    public?: boolean;
+    private?: boolean;
+    noCache?: boolean;
+    noStore?: boolean;
+    maxAge?: number;
+    sMaxAge?: number;
+    staleWhileRevalidate?: number;
+    staleIfError?: number;
+    mustRevalidate?: boolean;
+    immutable?: boolean;
+}
+/**
+ * Not found error - triggers 404 handling
+ */
+declare function notFound(message?: string): never;
+/**
+ * Check if error is a not found error
+ */
+declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Redirect error - triggers redirect handling
+ */
+declare function redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): never;
+/**
+ * Check if error is a redirect error
+ */
+declare function isRedirectError(error: unknown): error is Error & {
+    __flight_redirect: {
+        url: string;
+        status: number;
+    };
+};
+/**
+ * Get redirect info from error
+ */
+declare function getRedirectInfo(error: Error & {
+    __flight_redirect: {
+        url: string;
+        status: number;
+    };
+}): {
+    url: string;
+    status: number;
+};
+
+export { type CacheControlOptions, type ContextExtensions, type CookieAccessor, type CookieOptions, type ServerContext, type ServerContextOptions, acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming };

package/dist/rsc/context.js

@@ -0,0 +1,3 @@
+export { acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from '../chunk-MZXCF35B.js';
+//# sourceMappingURL=context.js.map
+//# sourceMappingURL=context.js.map

package/dist/rsc/context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"context.js"}

package/dist/rsc/index.d.ts

@@ -0,0 +1,232 @@
+import { ServerContext } from './context.js';
+export { CacheControlOptions, ContextExtensions, CookieAccessor, CookieOptions, ServerContextOptions, acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from './context.js';
+import { FlightElement } from './payload.js';
+export { ClientReferenceChunk, ErrorBoundaryChunk, FlightChunk, FlightClientElement, FlightFragmentElement, FlightHostElement, FlightLazyElement, FlightNullElement, FlightPayloadError, FlightSerializationError, FlightSuspenseElement, FlightTextElement, HintChunk, MetaChunk, SerializedSpecialValue, SerializedValue, ServerComponentChunk, ServerReferenceChunk, SpecialValueType, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from './payload.js';
+export { BoundaryRegistry, BoundaryType, CLIENT_REFERENCE, ClientReference, ComponentBoundary, ModuleAnalysis, SERVER_REFERENCE, ServerReference, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from './boundaries.js';
+export { FlightResponseOptions, FlightStreamError, FlightStreamOptions, FlightStreamResult, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from './stream.js';
+export { ComponentFn, ElementTypeInfo, FlightRenderer, RenderOptions, RenderResult, UIAdapter, createRenderer, renderServerComponent, renderServerComponentStreaming } from './renderer.js';
+export { ReactConsumerOptions, ReactServerComponent, createReactAdapter, createReactConsumer, markAsClientComponent } from './adapters/react.js';
+export { ClientManifestEntry, FlightRSCPluginOptions, ServerManifestEntry, default as flightRSC } from './vite-plugin.js';
+export { AsyncErrorBoundaryOptions, ComponentType, ClientComponent as LegacyClientComponent, ServerComponent as LegacyServerComponent, RenderContext, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError as legacyIsNotFoundError, isRedirectError as legacyIsRedirectError, notFound as legacyNotFound, redirect as legacyRedirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withAsyncErrorBoundary, withErrorBoundary } from './legacy.js';
+import 'react';
+import 'vite';
+
+/**
+ * @flightdev/core - RSC Type Helpers
+ *
+ * Type utilities for async server components, loaders, and actions.
+ * These types provide better TypeScript inference and developer experience.
+ *
+ * @module @flightdev/core/rsc/types
+ */
+
+/**
+ * Type for async server components with data fetching.
+ *
+ * @example
+ * ```typescript
+ * const UserPage: AsyncServerComponent<{ id: string }> = async ({ id }, ctx) => {
+ *     const user = await db.users.get(id);
+ *     return h('div', null, text(user.name));
+ * };
+ * ```
+ */
+type AsyncServerComponent<Props = Record<string, unknown>, Result = FlightElement> = (props: Props, ctx: ServerContext) => Promise<Result>;
+/**
+ * Type for sync server components.
+ */
+type SyncServerComponent<Props = Record<string, unknown>, Result = FlightElement> = (props: Props, ctx: ServerContext) => Result;
+/**
+ * Union type for any server component (sync or async).
+ */
+type ServerComponent<Props = Record<string, unknown>, Result = FlightElement> = AsyncServerComponent<Props, Result> | SyncServerComponent<Props, Result>;
+/**
+ * Context provided to loader functions.
+ */
+interface LoaderContext {
+    /** Route parameters extracted from the URL path */
+    params: Record<string, string>;
+    /** The incoming request object */
+    request: Request;
+    /** URL search parameters */
+    searchParams: URLSearchParams;
+}
+/**
+ * Type for loader functions.
+ *
+ * @example
+ * ```typescript
+ * export const loader: LoaderFn = async ({ params }) => {
+ *     const user = await db.users.get(params.id);
+ *     return { user };
+ * };
+ * ```
+ */
+type LoaderFn<T = unknown> = (context: LoaderContext) => Promise<T> | T;
+/**
+ * Infer the return type of a loader function.
+ *
+ * @example
+ * ```typescript
+ * export async function loader() {
+ *     return { count: 42, items: ['a', 'b'] };
+ * }
+ *
+ * // Type is { count: number; items: string[] }
+ * type Data = InferLoaderData<typeof loader>;
+ * ```
+ */
+type InferLoaderData<T extends (...args: never[]) => unknown> = Awaited<ReturnType<T>>;
+/**
+ * Context provided to action functions.
+ */
+interface ActionContext {
+    /** The incoming request object */
+    request: Request;
+    /** Route parameters extracted from the URL path */
+    params: Record<string, string>;
+}
+/**
+ * Type for action functions.
+ *
+ * @example
+ * ```typescript
+ * export const action: ActionFn = async ({ request }) => {
+ *     const formData = await request.formData();
+ *     await db.items.create({ name: formData.get('name') });
+ *     return { success: true };
+ * };
+ * ```
+ */
+type ActionFn<T = unknown> = (context: ActionContext) => Promise<T> | T;
+/**
+ * Infer the return type of an action function.
+ *
+ * @example
+ * ```typescript
+ * export async function action() {
+ *     return { success: true, id: '123' };
+ * }
+ *
+ * // Type is { success: boolean; id: string }
+ * type Result = InferActionReturn<typeof action>;
+ * ```
+ */
+type InferActionReturn<T extends (...args: never[]) => unknown> = Awaited<ReturnType<T>>;
+/**
+ * Extract props type from a component function.
+ *
+ * @example
+ * ```typescript
+ * async function UserCard(props: { name: string; age: number }) {
+ *     return <div>{props.name}</div>;
+ * }
+ *
+ * // Type is { name: string; age: number }
+ * type Props = ComponentProps<typeof UserCard>;
+ * ```
+ */
+type ComponentProps<T> = T extends (props: infer P, ...args: unknown[]) => unknown ? P : never;
+/**
+ * Extract the return type of a component (after awaiting if async).
+ */
+type ComponentReturn<T> = T extends (...args: unknown[]) => infer R ? Awaited<R> : never;
+/**
+ * Props for page components with route parameters.
+ */
+interface PageProps<Params extends Record<string, string> = Record<string, string>> {
+    /** Route parameters from dynamic segments */
+    params: Params;
+    /** URL search parameters */
+    searchParams?: Record<string, string | string[]>;
+}
+/**
+ * Type for page components.
+ *
+ * @example
+ * ```typescript
+ * const PostPage: PageComponent<{ slug: string }> = async ({ params }) => {
+ *     const post = await getPost(params.slug);
+ *     return <article>{post.title}</article>;
+ * };
+ * ```
+ */
+type PageComponent<Params extends Record<string, string> = Record<string, string>> = AsyncServerComponent<PageProps<Params>>;
+/**
+ * Props for layout components.
+ */
+interface LayoutProps<Params extends Record<string, string> = Record<string, string>> {
+    /** Child components to render */
+    children: FlightElement;
+    /** Route parameters from dynamic segments */
+    params: Params;
+}
+/**
+ * Type for layout components.
+ */
+type LayoutComponent<Params extends Record<string, string> = Record<string, string>> = ServerComponent<LayoutProps<Params>>;
+/**
+ * Props for error boundary components.
+ */
+interface ErrorProps {
+    /** The error that was thrown */
+    error: Error;
+    /** Function to reset the error boundary */
+    reset: () => void;
+}
+/**
+ * Type for error components.
+ */
+type ErrorComponent = (props: ErrorProps) => FlightElement;
+/**
+ * Type for loading components (shown during Suspense).
+ */
+type LoadingComponent = () => FlightElement;
+/**
+ * Generate metadata for a page.
+ */
+type GenerateMetadata<Params extends Record<string, string> = Record<string, string>> = (props: PageProps<Params>) => Promise<Metadata> | Metadata;
+/**
+ * Page metadata type.
+ */
+interface Metadata {
+    title?: string | {
+        default: string;
+        template?: string;
+    };
+    description?: string;
+    keywords?: string[];
+    authors?: Array<{
+        name: string;
+        url?: string;
+    }>;
+    openGraph?: {
+        title?: string;
+        description?: string;
+        images?: string[];
+        url?: string;
+        type?: string;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'player' | 'app';
+        title?: string;
+        description?: string;
+        images?: string[];
+    };
+    robots?: string | {
+        index?: boolean;
+        follow?: boolean;
+    };
+}
+
+/**
+ * Server Component function type
+ * @deprecated Use AsyncServerComponent or ServerComponent from './types.js'
+ */
+type ServerComponentFn<P = unknown, R = FlightElement> = (props: P, ctx: ServerContext) => R | Promise<R>;
+/**
+ * Server Action function type
+ */
+type ServerActionFn<Args extends unknown[] = unknown[], R = unknown> = (...args: Args) => Promise<R>;
+
+export { type ActionContext, type ActionFn, type AsyncServerComponent, type ComponentProps, type ComponentReturn, type ErrorComponent, type ErrorProps, FlightElement, type GenerateMetadata, type InferActionReturn, type InferLoaderData, type LayoutComponent, type LayoutProps, type LoaderContext, type LoaderFn, type LoadingComponent, type Metadata, type PageComponent, type PageProps, type ServerActionFn, type ServerComponent, type ServerComponentFn, ServerContext, type SyncServerComponent };

package/dist/rsc/index.js

@@ -0,0 +1,15 @@
+import '../chunk-63SCEXD7.js';
+import '../chunk-Y22AMGTM.js';
+export { createReactAdapter, createReactConsumer, markAsClientComponent } from '../chunk-AE3JTS73.js';
+import '../chunk-DCLVXFVH.js';
+import '../chunk-7ZZF4ULK.js';
+import '../chunk-KX6UYWWR.js';
+export { acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from '../chunk-MZXCF35B.js';
+export { FlightStreamError, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from '../chunk-SUG56SZO.js';
+export { FlightRenderer, createRenderer, renderServerComponent, renderServerComponentStreaming } from '../chunk-P6S43FYZ.js';
+export { FlightPayloadError, FlightSerializationError, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from '../chunk-7CNW24MQ.js';
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError as legacyIsNotFoundError, isRedirectError as legacyIsRedirectError, notFound as legacyNotFound, redirect as legacyRedirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withAsyncErrorBoundary, withErrorBoundary } from '../chunk-Z7G23XWU.js';
+export { flightRSC } from '../chunk-63LWTEDQ.js';
+export { BoundaryRegistry, CLIENT_REFERENCE, SERVER_REFERENCE, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from '../chunk-AP5NLUSB.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/rsc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/rsc/legacy.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @flightdev/core - Legacy RSC Support
+ *
+ * Backward compatibility module for the original RSC implementation.
+ * Use the new API from './index.js' for new features.
+ *
+ * @deprecated Use the new RSC API instead
+ * @module @flightdev/core/rsc/legacy
+ */
+/**
+ * Component rendering context
+ * @deprecated Use ServerContext from './context.js' instead
+ */
+interface RenderContext {
+    /** Current request */
+    request: Request;
+    /** Route params */
+    params: Record<string, string>;
+    /** Search params */
+    searchParams: URLSearchParams;
+    /** Request headers */
+    headers: Headers;
+    /** Cookies */
+    cookies: Map<string, string>;
+}
+/**
+ * Server component definition
+ * @deprecated Use ServerComponentFn from './index.js' instead
+ */
+interface ServerComponent<P = unknown> {
+    (props: P, context: RenderContext): Promise<string> | string;
+    /** Mark as server component */
+    __flight_server?: true;
+    /** Dependencies for hydration */
+    __flight_deps?: string[];
+}
+/**
+ * Client component definition
+ * @deprecated Use ClientReference from './boundaries.js' instead
+ */
+interface ClientComponent<P = unknown> {
+    (props: P): unknown;
+    /** Mark as client component */
+    __flight_client?: true;
+    /** Client bundle path */
+    __flight_bundle?: string;
+}
+/**
+ * Component type detection
+ */
+type ComponentType = 'server' | 'client' | 'hybrid';
+/**
+ * Execute an async server component
+ * @deprecated Use the new rendering pipeline instead
+ */
+declare function executeServerComponent<P>(component: ServerComponent<P>, props: P, context: RenderContext): Promise<string>;
+/**
+ * Create a render context from a Request
+ * @deprecated Use createServerContext from './context.js' instead
+ */
+declare function createRenderContext(request: Request, params?: Record<string, string>): RenderContext;
+/**
+ * Server-side fetch with automatic caching
+ */
+declare function serverFetch<T>(url: string, options?: RequestInit & {
+    revalidate?: number | false;
+    tags?: string[];
+}): Promise<T>;
+/**
+ * Invalidate cache by tag
+ */
+declare function revalidateTag(tag: string): void;
+/**
+ * Invalidate cache by path
+ */
+declare function revalidatePath(path: string): void;
+/**
+ * Serialize props for transmission to client
+ * @deprecated Use serialize from './payload.js' instead
+ */
+declare function serializeProps(props: unknown): string;
+/**
+ * Deserialize props on client
+ * @deprecated Use deserialize from './payload.js' instead
+ */
+declare function deserializeProps<T>(serialized: string): T;
+/**
+ * Create a client boundary placeholder
+ * @deprecated Use clientRef from './payload.js' instead
+ */
+declare function createClientBoundary(componentId: string, props: unknown, fallback?: string): string;
+/**
+ * Helper to create an async server component
+ * @deprecated Use async Server Components directly
+ */
+declare function createAsyncComponent<P, T>(fetcher: (props: P, context: RenderContext) => Promise<T>, renderer: (data: T, props: P) => string): ServerComponent<P>;
+/**
+ * Compose multiple server components
+ * @deprecated Use Promise.all with async components
+ */
+declare function composeComponents(...components: Array<() => Promise<string> | string>): () => Promise<string>;
+/**
+ * Options for async error boundary
+ */
+interface AsyncErrorBoundaryOptions<P, R> {
+    /** Fallback to render on error */
+    fallback: (error: Error, props: P) => R;
+    /** Optional callback when error occurs */
+    onError?: (error: Error, props: P, context: RenderContext) => void;
+    /** Whether to rethrow certain errors (e.g., redirects, not found) */
+    rethrowNavigation?: boolean;
+}
+/**
+ * Wrap an async server component with comprehensive error handling.
+ *
+ * @example
+ * ```typescript
+ * const SafeUserPage = withAsyncErrorBoundary(UserPage, {
+ *     fallback: (error, props) => `<div>Error loading user ${props.id}</div>`,
+ *     onError: (error, props) => console.error(`Failed to load user ${props.id}:`, error),
+ *     rethrowNavigation: true,
+ * });
+ * ```
+ */
+declare function withAsyncErrorBoundary<P, R = string>(component: (props: P, context: RenderContext) => Promise<R> | R, options: AsyncErrorBoundaryOptions<P, R>): (props: P, context: RenderContext) => Promise<R>;
+/**
+ * Wrap a server component with error handling
+ * @deprecated Use withAsyncErrorBoundary instead
+ */
+declare function withErrorBoundary<P>(component: ServerComponent<P>, errorFallback: (error: Error) => string): ServerComponent<P>;
+/**
+ * Throw a not found error
+ * @deprecated Use notFound from './context.js' instead
+ */
+declare function notFound(): never;
+/**
+ * Check if error is not found
+ * @deprecated Use isNotFoundError from './context.js' instead
+ */
+declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Server-side redirect
+ * @deprecated Use redirect from './context.js' instead
+ */
+declare function redirect(url: string, type?: 'replace' | 'push'): never;
+/**
+ * Check if error is redirect
+ * @deprecated Use isRedirectError from './context.js' instead
+ */
+declare function isRedirectError(error: unknown): {
+    url: string;
+    type: string;
+} | null;
+
+export { type AsyncErrorBoundaryOptions, type ClientComponent, type ComponentType, type RenderContext, type ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withAsyncErrorBoundary, withErrorBoundary };

package/dist/rsc/legacy.js

@@ -0,0 +1,3 @@
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withAsyncErrorBoundary, withErrorBoundary } from '../chunk-Z7G23XWU.js';
+//# sourceMappingURL=legacy.js.map
+//# sourceMappingURL=legacy.js.map

package/dist/rsc/legacy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"legacy.js"}