@flight-framework/core 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { FlightConfig, FlightUserConfig, defineConfig } from './config/index.js';
+export { Route, RouteMatch, RouteParams, Router, createRouter } from './router/index.js';
+export { FlightServer, RouteHandler, RouteHandlerContext, ServerOptions, ServerRoute, createServer } from './server/index.js';
+export { RenderContext, RenderMode, RenderResult } from './render/index.js';
+export { Cache, CacheOptions, createCache } from './cache/index.js';
+export { Middleware, MiddlewareContext, MiddlewareNext, createMiddlewareChain } from './middleware/index.js';
+export { AdapterBuilder, FlightAdapter } from './adapters/index.js';
+export { FileRoute, FileRouter, FileRouterOptions, ScanResult, createFileRouter, loadRoutes, scanRoutes } from './file-router/index.js';
+export { HttpMethod as FileHttpMethod, RouteHandler as FileRouteHandler, RouteHandlerContext as FileRouteHandlerContext, createRouteContext, error, json, parseBody, redirect } from './handlers/index.js';
+export { ActionResult, CookieOptions, RedirectError, ServerAction, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './actions/index.js';
+export { StreamingRenderOptions, StreamingRenderResult, SuspenseBoundaryConfig, createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './streaming/index.js';
+export { ClientComponent, ComponentType as RSCComponentType, RenderContext as RSCRenderContext, ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError as isRscRedirectError, notFound, revalidatePath, revalidateTag, redirect as rscRedirect, serializeProps, serverFetch, withErrorBoundary } from './rsc/index.js';
+
+/**
+ * Flight Framework - Core
+ *
+ * The agnostic full-stack framework primitives.
+ * Maximum flexibility, zero lock-in.
+ */
+
+declare const VERSION = "0.0.1";
+
+export { VERSION };

package/dist/index.js

@@ -0,0 +1,19 @@
+export { createFileRouter, loadRoutes, scanRoutes } from './chunk-I5RHYGX6.js';
+export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-TKXN7KGE.js';
+export { createRouteContext, error, json, parseBody, redirect } from './chunk-AJ3IBYXT.js';
+export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-QEFGUHYD.js';
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError as isRscRedirectError, notFound, revalidatePath, revalidateTag, redirect as rscRedirect, serializeProps, serverFetch, withErrorBoundary } from './chunk-AFSKXC6V.js';
+import './chunk-ZVC3ZWLM.js';
+export { createCache } from './chunk-3AIQVGTM.js';
+import './chunk-Q4C5CCHK.js';
+export { createServer } from './chunk-Y22KEW2F.js';
+export { createRouter } from './chunk-GCQZ4FHI.js';
+export { createMiddlewareChain } from './chunk-KWFX6WHG.js';
+export { defineConfig } from './chunk-WAGCTWGY.js';
+
+// src/index.ts
+var VERSION = "0.0.1";
+
+export { VERSION };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAyIO,IAAM,OAAA,GAAU","file":"index.js","sourcesContent":["/**\r\n * Flight Framework - Core\r\n * \r\n * The agnostic full-stack framework primitives.\r\n * Maximum flexibility, zero lock-in.\r\n */\r\n\r\n// Configuration\r\nexport { defineConfig, type FlightConfig, type FlightUserConfig } from './config/index.js';\r\n\r\n// Router\r\nexport {\r\n    createRouter,\r\n    type Route,\r\n    type RouteMatch,\r\n    type Router,\r\n    type RouteParams,\r\n} from './router/index.js';\r\n\r\n// Server\r\nexport {\r\n    createServer,\r\n    type FlightServer,\r\n    type RouteHandler,\r\n    type RouteHandlerContext,\r\n    type ServerOptions,\r\n    type ServerRoute,\r\n} from './server/index.js';\r\n\r\n// Render\r\nexport {\r\n    type RenderMode,\r\n    type RenderContext,\r\n    type RenderResult,\r\n} from './render/index.js';\r\n\r\n// Cache\r\nexport {\r\n    createCache,\r\n    type Cache,\r\n    type CacheOptions,\r\n} from './cache/index.js';\r\n\r\n// Middleware\r\nexport {\r\n    createMiddlewareChain,\r\n    type Middleware,\r\n    type MiddlewareContext,\r\n    type MiddlewareNext,\r\n} from './middleware/index.js';\r\n\r\n// Adapters\r\nexport {\r\n    type FlightAdapter,\r\n    type AdapterBuilder,\r\n} from './adapters/index.js';\r\n\r\n// File Router\r\nexport {\r\n    createFileRouter,\r\n    scanRoutes,\r\n    loadRoutes,\r\n    type FileRoute,\r\n    type FileRouter,\r\n    type FileRouterOptions,\r\n    type ScanResult,\r\n} from './file-router/index.js';\r\n\r\n// Route Handlers (for file-based routing)\r\nexport {\r\n    createRouteContext,\r\n    json,\r\n    redirect,\r\n    error,\r\n    parseBody,\r\n    type RouteHandler as FileRouteHandler,\r\n    type RouteHandlerContext as FileRouteHandlerContext,\r\n    type HttpMethod as FileHttpMethod,\r\n} from './handlers/index.js';\r\n\r\n// Server Actions\r\nexport {\r\n    registerAction,\r\n    getAction,\r\n    executeAction,\r\n    executeFormAction,\r\n    handleActionRequest,\r\n    cookies,\r\n    redirect as actionRedirect,\r\n    parseFormData,\r\n    RedirectError,\r\n    isRedirectError,\r\n    type ServerAction,\r\n    type ActionResult,\r\n    type CookieOptions,\r\n} from './actions/index.js';\r\n\r\n// Streaming SSR\r\nexport {\r\n    createStreamingSSR,\r\n    createStreamingResponse,\r\n    renderWithStreaming,\r\n    createLazyContent,\r\n    streamParallel,\r\n    streamSequential,\r\n    type StreamingRenderOptions,\r\n    type StreamingRenderResult,\r\n    type SuspenseBoundaryConfig,\r\n} from './streaming/index.js';\r\n\r\n// React Server Components (RSC) Primitives\r\nexport {\r\n    hasUseClientDirective,\r\n    hasUseServerDirective,\r\n    detectComponentType,\r\n    createRenderContext,\r\n    executeServerComponent,\r\n    serverFetch,\r\n    revalidateTag,\r\n    revalidatePath,\r\n    serializeProps,\r\n    deserializeProps,\r\n    createClientBoundary,\r\n    createAsyncComponent,\r\n    composeComponents,\r\n    withErrorBoundary,\r\n    notFound,\r\n    isNotFoundError,\r\n    redirect as rscRedirect,\r\n    isRedirectError as isRscRedirectError,\r\n    type RenderContext as RSCRenderContext,\r\n    type ServerComponent,\r\n    type ClientComponent,\r\n    type ComponentType as RSCComponentType,\r\n} from './rsc/index.js';\r\n\r\n// Version\r\nexport const VERSION = '0.0.1';\r\n"]}

package/dist/middleware/index.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Flight Middleware - Composable request/response handlers
+ *
+ * Framework-agnostic middleware system inspired by Koa/Hono.
+ */
+/** Request context passed through middleware chain */
+interface MiddlewareContext {
+    /** Request URL */
+    url: URL;
+    /** Request method */
+    method: string;
+    /** Request headers */
+    headers: Headers;
+    /** URL parameters from routing */
+    params: Record<string, string | string[]>;
+    /** Query parameters */
+    query: URLSearchParams;
+    /** Parsed request body (if any) */
+    body?: unknown;
+    /** Local data shared between middleware */
+    locals: Record<string, unknown>;
+    /** Original request (platform-specific) */
+    request?: Request;
+    /** Response status code */
+    status: number;
+    /** Response headers */
+    responseHeaders: Headers;
+    /** Response body */
+    responseBody?: BodyInit | null;
+}
+/** Next function to call the next middleware */
+type MiddlewareNext = () => Promise<void>;
+/** Middleware function signature */
+type Middleware = (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<void> | void;
+/** Middleware with optional path matching */
+interface MiddlewareDefinition {
+    /** Path pattern to match (undefined = match all) */
+    path?: string | RegExp;
+    /** HTTP methods to match (undefined = match all) */
+    methods?: string[];
+    /** The middleware function */
+    handler: Middleware;
+}
+interface MiddlewareChain {
+    /** Add middleware to the chain */
+    use(middleware: Middleware): MiddlewareChain;
+    use(path: string, middleware: Middleware): MiddlewareChain;
+    use(definition: MiddlewareDefinition): MiddlewareChain;
+    /** Execute the middleware chain */
+    execute(ctx: MiddlewareContext): Promise<void>;
+    /** Get all middleware definitions */
+    middlewares(): MiddlewareDefinition[];
+}
+/**
+ * Create a new middleware chain
+ */
+declare function createMiddlewareChain(): MiddlewareChain;
+/**
+ * CORS middleware factory
+ */
+declare function cors(options?: {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    headers?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}): Middleware;
+/** Log levels in order of verbosity */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/** Log format types */
+type LogFormat = 'pretty' | 'json' | 'combined' | 'common' | 'short' | 'tiny';
+/** Log entry structure for JSON format */
+interface LogEntry {
+    timestamp: string;
+    level: LogLevel;
+    method: string;
+    path: string;
+    status: number;
+    duration: number;
+    userAgent?: string;
+    ip?: string;
+    [key: string]: unknown;
+}
+/** Custom log writer function */
+type LogWriter = (entry: LogEntry, formatted: string) => void;
+/** Logger options */
+interface LoggerOptions {
+    /** Minimum log level (default: 'info') */
+    level?: LogLevel;
+    /** Output format (default: 'pretty') */
+    format?: LogFormat;
+    /** Skip logging for certain requests */
+    skip?: (ctx: MiddlewareContext) => boolean;
+    /** Custom log writer (replaces console output) */
+    writer?: LogWriter;
+    /** Include request headers in logs */
+    includeHeaders?: boolean;
+    /** Colorize output (only for 'pretty' format, default: true) */
+    colorize?: boolean;
+}
+/**
+ * Professional logger middleware with configurable levels
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * server.use(logger());
+ *
+ * // With level control
+ * server.use(logger({ level: 'warn' })); // Only warn and error
+ *
+ * // JSON format for production/observability
+ * server.use(logger({ format: 'json', level: 'info' }));
+ *
+ * // Custom writer (e.g., for external logging service)
+ * server.use(logger({
+ *     writer: (entry) => myLoggingService.log(entry)
+ * }));
+ *
+ * // Silent in production
+ * server.use(logger({ level: process.env.NODE_ENV === 'production' ? 'error' : 'debug' }));
+ * ```
+ */
+declare function logger(options?: LoggerOptions): Middleware;
+/**
+ * Security headers middleware
+ */
+declare function securityHeaders(options?: {
+    contentSecurityPolicy?: string | false;
+    xFrameOptions?: 'DENY' | 'SAMEORIGIN' | false;
+    xContentTypeOptions?: boolean;
+    referrerPolicy?: string;
+    permissionsPolicy?: string;
+}): Middleware;
+/**
+ * Compression middleware (requires implementation in adapter)
+ */
+declare function compress(): Middleware;
+/**
+ * Create a middleware context from a Web Request
+ */
+declare function createContextFromRequest(request: Request, params?: Record<string, string | string[]>): MiddlewareContext;
+/**
+ * Create a Web Response from middleware context
+ */
+declare function createResponseFromContext(ctx: MiddlewareContext): Response;
+/**
+ * Compose multiple middleware into one
+ */
+declare function compose(...middlewares: Middleware[]): Middleware;
+
+export { type LogEntry, type LogFormat, type LogLevel, type LogWriter, type LoggerOptions, type Middleware, type MiddlewareChain, type MiddlewareContext, type MiddlewareDefinition, type MiddlewareNext, compose, compress, cors, createContextFromRequest, createMiddlewareChain, createResponseFromContext, logger, securityHeaders };

package/dist/middleware/index.js

@@ -0,0 +1,3 @@
+export { compose, compress, cors, createContextFromRequest, createMiddlewareChain, createResponseFromContext, logger, securityHeaders } from '../chunk-KWFX6WHG.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/middleware/index.js.map

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

package/dist/render/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Flight Render Engine - Universal rendering primitives
+ *
+ * Supports SSR, SSG, CSR, and ISR - the user chooses per route.
+ */
+/** Rendering modes supported by Flight */
+type RenderMode = 'ssr' | 'ssg' | 'csr' | 'isr';
+/** Context passed to render functions */
+interface RenderContext {
+    /** The URL being rendered */
+    url: URL;
+    /** Route parameters */
+    params: Record<string, string | string[]>;
+    /** Request headers (available in SSR/ISR) */
+    headers?: Headers;
+    /** Cookies (available in SSR/ISR) */
+    cookies?: Record<string, string>;
+    /** Request method */
+    method?: string;
+    /** Request body (for POST/PUT/etc) */
+    body?: unknown;
+    /** Custom context data */
+    locals?: Record<string, unknown>;
+}
+/** Result of a render operation */
+interface RenderResult {
+    /** HTML content */
+    html: string;
+    /** HTTP status code */
+    status: number;
+    /** Response headers */
+    headers: Record<string, string>;
+    /** Head elements to inject */
+    head?: {
+        title?: string;
+        meta?: Array<{
+            name?: string;
+            property?: string;
+            content: string;
+        }>;
+        links?: Array<{
+            rel: string;
+            href: string;
+            [key: string]: string;
+        }>;
+        scripts?: Array<{
+            src?: string;
+            content?: string;
+            type?: string;
+        }>;
+        styles?: Array<{
+            href?: string;
+            content?: string;
+        }>;
+    };
+}
+/** Configuration for SSG/ISR */
+interface StaticRenderConfig {
+    /** Paths to pre-render */
+    paths: string[] | (() => Promise<string[]>);
+    /** Fallback behavior for non-pre-rendered paths */
+    fallback?: 'blocking' | 'prerender' | false;
+}
+/** Configuration for ISR */
+interface ISRConfig extends StaticRenderConfig {
+    /** Revalidation time in seconds */
+    revalidate: number;
+}
+/**
+ * Check if a render mode requires server runtime
+ */
+declare function requiresServer(mode: RenderMode): boolean;
+/**
+ * Check if a render mode can be statically generated
+ */
+declare function canBeStatic(mode: RenderMode): boolean;
+/**
+ * Check if a render mode is purely client-side
+ */
+declare function isClientOnly(mode: RenderMode): boolean;
+/**
+ * UI Framework Integration Interface
+ *
+ * Each UI framework (React, Vue, Svelte, etc.) implements this interface
+ * to integrate with Flight's render engine.
+ */
+interface UIFrameworkAdapter<Component = unknown> {
+    /** Framework name */
+    name: string;
+    /**
+     * Render a component to HTML string (for SSR/SSG)
+     */
+    renderToString(component: Component, context: RenderContext): Promise<RenderResult>;
+    /**
+     * Render a component to a stream (for streaming SSR)
+     */
+    renderToStream?(component: Component, context: RenderContext): Promise<ReadableStream<Uint8Array>>;
+    /**
+     * Generate client hydration script
+     */
+    getHydrationScript?(component: Component): string;
+    /**
+     * File extensions this adapter handles
+     */
+    extensions: string[];
+}
+/**
+ * Create a minimal HTML shell
+ */
+declare function createHTMLShell(options: {
+    head?: string;
+    body: string;
+    scripts?: string[];
+    styles?: string[];
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
+}): string;
+/**
+ * Escape HTML special characters
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Create a CSR shell (minimal HTML that loads client bundle)
+ */
+declare function createCSRShell(options: {
+    title?: string;
+    entryScript: string;
+    rootId?: string;
+}): RenderResult;
+
+export { type ISRConfig, type RenderContext, type RenderMode, type RenderResult, type StaticRenderConfig, type UIFrameworkAdapter, canBeStatic, createCSRShell, createHTMLShell, escapeHtml, isClientOnly, requiresServer };

package/dist/render/index.js

@@ -0,0 +1,3 @@
+export { canBeStatic, createCSRShell, createHTMLShell, escapeHtml, isClientOnly, requiresServer } from '../chunk-ZVC3ZWLM.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/render/index.js.map

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

package/dist/router/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Flight Router - File-based routing with dynamic patterns
+ */
+interface RouteParams {
+    [key: string]: string | string[];
+}
+interface Route<T = unknown> {
+    /** Route path pattern (e.g., '/blog/[slug]', '/api/[...path]') */
+    path: string;
+    /** Handler or component for this route */
+    handler: T;
+    /** Rendering mode for this route */
+    mode?: 'ssr' | 'ssg' | 'csr' | 'isr';
+    /** Metadata for the route */
+    meta?: Record<string, unknown>;
+}
+interface RouteMatch<T = unknown> {
+    /** The matched route */
+    route: Route<T>;
+    /** Extracted parameters from the URL */
+    params: RouteParams;
+    /** The original path that was matched */
+    path: string;
+}
+interface Router<T = unknown> {
+    /** Add a route to the router */
+    add(route: Route<T>): void;
+    /** Add multiple routes */
+    addAll(routes: Route<T>[]): void;
+    /** Match a path against registered routes */
+    match(path: string): RouteMatch<T> | null;
+    /** Get all registered routes */
+    routes(): Route<T>[];
+    /** Remove a route by path */
+    remove(path: string): boolean;
+}
+/**
+ * Create a new Flight router instance
+ */
+declare function createRouter<T = unknown>(): Router<T>;
+interface FileRoute {
+    /** File path relative to routes directory */
+    filePath: string;
+    /** Generated route path */
+    routePath: string;
+}
+/**
+ * Convert a file path to a route path
+ *
+ * Examples:
+ * - index.tsx -> /
+ * - about.tsx -> /about
+ * - blog/index.tsx -> /blog
+ * - blog/[slug].tsx -> /blog/[slug]
+ * - api/[...path].ts -> /api/[...path]
+ * - (group)/settings.tsx -> /settings (groups are ignored)
+ */
+declare function filePathToRoutePath(filePath: string): string;
+/**
+ * Sort routes by specificity (most specific first)
+ * Static routes come before dynamic routes
+ */
+declare function sortRoutes<T>(routes: Route<T>[]): Route<T>[];
+
+export { type FileRoute, type Route, type RouteMatch, type RouteParams, type Router, createRouter, filePathToRoutePath, sortRoutes };

package/dist/router/index.js

@@ -0,0 +1,3 @@
+export { createRouter, filePathToRoutePath, sortRoutes } from '../chunk-GCQZ4FHI.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/router/index.js.map

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

package/dist/rsc/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @flight/core - React Server Components Support
+ *
+ * Framework-agnostic primitives for RSC-like patterns.
+ * Enables async server components, client/server boundaries, and data fetching.
+ *
+ * Best Practices 2025/2026:
+ * - Async components for server-side data fetching
+ * - 'use client' / 'use server' directive detection
+ * - Automatic component serialization
+ * - Props passing between server and client
+ */
+/**
+ * Component rendering context
+ */
+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
+ */
+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
+ */
+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';
+/**
+ * Check if a file has 'use client' directive
+ */
+declare function hasUseClientDirective(source: string): boolean;
+/**
+ * Check if a file has 'use server' directive
+ */
+declare function hasUseServerDirective(source: string): boolean;
+/**
+ * Detect component type from source
+ */
+declare function detectComponentType(source: string): ComponentType;
+/**
+ * Execute an async server component
+ */
+declare function executeServerComponent<P>(component: ServerComponent<P>, props: P, context: RenderContext): Promise<string>;
+/**
+ * Create a render context from a Request
+ */
+declare function createRenderContext(request: Request, params?: Record<string, string>): RenderContext;
+/**
+ * Server-side fetch with automatic caching (like Next.js fetch extensions)
+ */
+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
+ */
+declare function serializeProps(props: unknown): string;
+/**
+ * Deserialize props on client
+ */
+declare function deserializeProps<T>(serialized: string): T;
+/**
+ * Create a client boundary placeholder
+ */
+declare function createClientBoundary(componentId: string, props: unknown, fallback?: string): string;
+/**
+ * Helper to create an async server component
+ */
+declare function createAsyncComponent<P, T>(fetcher: (props: P, context: RenderContext) => Promise<T>, renderer: (data: T, props: P) => string): ServerComponent<P>;
+/**
+ * Compose multiple server components
+ */
+declare function composeComponents(...components: Array<() => Promise<string> | string>): () => Promise<string>;
+/**
+ * Wrap a server component with error handling
+ */
+declare function withErrorBoundary<P>(component: ServerComponent<P>, errorFallback: (error: Error) => string): ServerComponent<P>;
+/**
+ * Throw a not found error (like Next.js notFound())
+ */
+declare function notFound(): never;
+/**
+ * Check if error is not found
+ */
+declare function isNotFoundError(error: unknown): boolean;
+/**
+ * Server-side redirect (like Next.js redirect())
+ */
+declare function redirect(url: string, type?: 'replace' | 'push'): never;
+/**
+ * Check if error is redirect
+ */
+declare function isRedirectError(error: unknown): {
+    url: string;
+    type: string;
+} | null;
+
+export { type ClientComponent, type ComponentType, type RenderContext, type ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary };

package/dist/rsc/index.js

@@ -0,0 +1,3 @@
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, detectComponentType, executeServerComponent, hasUseClientDirective, hasUseServerDirective, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from '../chunk-AFSKXC6V.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"}