@flight-framework/core 0.3.0 → 0.3.2

package/dist/index.js

@@ -1,36 +1,36 @@
+export { streamWithPriority, validateDependencies } from './chunk-NZS2YJ43.js';
 export { MetricsAggregator, createHttpObserver, createInstrumentedStream, createLoggerObserver } from './chunk-YNTMYL36.js';
-export { DEFAULT_BOT_PATTERNS, addStreamingHeaders, createConditionalStreamer, createStreamingResponse as createConditionalStreamingResponse, createStaticResponse, isBot, isSlowConnection, prefersNoStream, streamIf, supportsStreaming } from './chunk-VNO2YUVD.js';
 export { createHTMXStreamAdapter, createReactStreamAdapter, createSolidStreamAdapter, createStreamAdapter, createSvelteStreamAdapter, createVueStreamAdapter } from './chunk-GNS2FGPC.js';
-export { createIslandRegistry, createPreactIslandAdapter, createReactIslandAdapter, createSolidIslandAdapter, createVueIslandAdapter, defineIsland, hydrateIslands, registerFlightIslandElement, registerIsland, renderIsland, renderIslands, setIslandAdapter } from './chunk-UFWGOJL7.js';
 export { DEFAULT_STREAMING_HINTS, createStreamingController, generateCacheKey, getStreamingCacheHeaders, hasStreamingConfig, isValidStreamingHints, loadRouteWithStreaming, resolveStreamingConfig, shouldStream } from './chunk-PO7IHPFF.js';
-export { streamWithPriority, validateDependencies } from './chunk-NZS2YJ43.js';
-import './chunk-QK6UEQ75.js';
-export { createServer } from './chunk-UL4Q5CIJ.js';
-export { defineConfig } from './chunk-EHVUAFNH.js';
-export { createFileRouter, loadRoutes, scanRoutes } from './chunk-UGTETAJ2.js';
-export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-OZ3EXPLE.js';
-export { createRouteContext, error, json, parseBody, redirect } from './chunk-A4TKWQBU.js';
-export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-CNY3ZUVG.js';
 import './chunk-63SCEXD7.js';
+import './chunk-Y22AMGTM.js';
+import './chunk-HNPO6LFW.js';
+import './chunk-3UQJE3XZ.js';
+import './chunk-3N5ZBVZJ.js';
+import './chunk-65JYF3DJ.js';
 export { createServerContext, isNotFoundError, isRedirectError as isRscRedirectError, notFound, redirect as rscRedirect } from './chunk-CKJHJPKQ.js';
 import './chunk-A2QRUBVE.js';
 import './chunk-FRAH5QNY.js';
 import './chunk-6GI6HFSQ.js';
-export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, revalidatePath as rscRevalidatePath, revalidateTag as rscRevalidateTag, serializeProps, serverFetch, withErrorBoundary } from './chunk-2R23X5Z3.js';
+export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, revalidatePath as rscRevalidatePath, revalidateTag as rscRevalidateTag, serializeProps, serverFetch, withErrorBoundary } from './chunk-6IG6XIXU.js';
 import './chunk-XU6MRYG2.js';
 export { detectBoundaryType, hasUseClientDirective, hasUseServerDirective } from './chunk-5XHOLZBJ.js';
-import './chunk-Y22AMGTM.js';
-import './chunk-HNPO6LFW.js';
-import './chunk-3UQJE3XZ.js';
-import './chunk-3N5ZBVZJ.js';
-import './chunk-65JYF3DJ.js';
+import './chunk-QK6UEQ75.js';
+export { createServer } from './chunk-KDEA64UX.js';
+export { createFileRouter, loadRoutes, scanRoutes } from './chunk-4U7CJVNQ.js';
+export { RedirectError, redirect as actionRedirect, cookies, executeAction, executeFormAction, getAction, handleActionRequest, isRedirectError, parseFormData, registerAction } from './chunk-OZ3EXPLE.js';
+export { createRouteContext, error, json, parseBody, redirect } from './chunk-A4TKWQBU.js';
+export { createLazyContent, createStreamingResponse, createStreamingSSR, renderWithStreaming, streamParallel, streamSequential } from './chunk-CNY3ZUVG.js';
+export { DEFAULT_BOT_PATTERNS, addStreamingHeaders, createConditionalStreamer, createStreamingResponse as createConditionalStreamingResponse, createStaticResponse, isBot, isSlowConnection, prefersNoStream, streamIf, supportsStreaming } from './chunk-VNO2YUVD.js';
+export { createIslandRegistry, createPreactIslandAdapter, createReactIslandAdapter, createSolidIslandAdapter, createVueIslandAdapter, defineIsland, hydrateIslands, registerFlightIslandElement, registerIsland, renderIsland, renderIslands, setIslandAdapter } from './chunk-UFWGOJL7.js';
+export { createMiddlewareChain } from './chunk-R7MEVVA4.js';
+export { defineConfig } from './chunk-EHVUAFNH.js';
 export { BadRequestError, FlightError, ForbiddenError, InternalError, NotFoundError, UnauthorizedError, clearError, createError, createErrorResponse, forbidden as createForbidden, notFound as createNotFound, unauthorized as createUnauthorized, getError, getErrorStatusCode, isFlightError, isForbiddenError as isForbidden, isNotFoundError as isNotFound, isUnauthorizedError as isUnauthorized, showError, wrapWithDigest } from './chunk-2JVEH76V.js';
 import './chunk-PL37KFRJ.js';
 export { getEnvironment, isBrowser, isDevelopment, isProduction, isServer, isTest } from './chunk-OZBPR27I.js';
 export { createRouter } from './chunk-ARBKF6VI.js';
 import './chunk-B2LPSCES.js';
 export { cacheKey, cached, createCache, dedupe, jsonSerializer, memory } from './chunk-LKOPJ3GS.js';
-export { createMiddlewareChain } from './chunk-JFUKVWSO.js';
 import { promises } from 'fs';
 import { dirname, join } from 'path';
 

package/dist/middleware/index.d.ts

@@ -2,9 +2,41 @@
  * Flight Middleware - Composable request/response handlers
  *
  * Framework-agnostic middleware system inspired by Koa/Hono.
+ * Provides primitives for building your own middleware solutions.
+ *
+ * @example
+ * ```typescript
+ * // Type-safe middleware with custom variables (Hono pattern)
+ * interface MyLocals {
+ *     user: { id: string; role: string };
+ *     requestId: string;
+ * }
+ *
+ * const authMiddleware: Middleware<MyLocals> = async (ctx, next) => {
+ *     ctx.locals.user = { id: '123', role: 'admin' };
+ *     await next();
+ * };
+ * ```
  */
-/** Request context passed through middleware chain */
-interface MiddlewareContext {
+/**
+ * Request context passed through middleware chain.
+ *
+ * Supports generic type parameter for type-safe locals (like Hono Variables).
+ *
+ * @typeParam TLocals - Type of the locals object for type-safe middleware data sharing
+ *
+ * @example
+ * ```typescript
+ * interface AppLocals {
+ *     user: User;
+ *     db: DatabaseClient;
+ * }
+ *
+ * const ctx: MiddlewareContext<AppLocals> = createContextFromRequest(request);
+ * ctx.locals.user = currentUser; // Type-safe!
+ * ```
+ */
+interface MiddlewareContext<TLocals extends Record<string, unknown> = Record<string, unknown>> {
     /** Request URL */
     url: URL;
     /** Request method */
@@ -17,8 +49,8 @@ interface MiddlewareContext {
     query: URLSearchParams;
     /** Parsed request body (if any) */
     body?: unknown;
-    /** Local data shared between middleware */
-    locals: Record<string, unknown>;
+    /** Local data shared between middleware - type-safe with generics */
+    locals: TLocals;
     /** Original request (platform-specific) */
     request?: Request;
     /** Response status code */
@@ -30,8 +62,12 @@ interface MiddlewareContext {
 }
 /** Next function to call the next middleware */
 type MiddlewareNext = () => Promise<void>;
-/** Middleware function signature */
-type Middleware = (ctx: MiddlewareContext, next: MiddlewareNext) => Promise<void> | void;
+/**
+ * Middleware function signature with optional typed locals.
+ *
+ * @typeParam TLocals - Type of the locals object for type-safe data sharing
+ */
+type Middleware<TLocals extends Record<string, unknown> = Record<string, unknown>> = (ctx: MiddlewareContext<TLocals>, next: MiddlewareNext) => Promise<void> | void;
 /** Middleware with optional path matching */
 interface MiddlewareDefinition {
     /** Path pattern to match (undefined = match all) */
@@ -58,13 +94,52 @@ declare function createMiddlewareChain(): MiddlewareChain;
 /**
  * CORS middleware factory
  */
-declare function cors(options?: {
-    origin?: string | string[] | ((origin: string) => boolean);
+/**
+ * CORS options for configuring cross-origin requests.
+ */
+interface CorsOptions {
+    /**
+     * Allowed origins. Can be:
+     * - '*' for any origin
+     * - A specific origin string
+     * - An array of allowed origins
+     * - A function that returns true if origin is allowed
+     * - An async function for dynamic origin validation
+     */
+    origin?: string | string[] | ((origin: string) => boolean | Promise<boolean>);
+    /** Allowed HTTP methods */
     methods?: string[];
+    /** Allowed headers */
     headers?: string[];
+    /** Whether to include credentials */
     credentials?: boolean;
+    /** Preflight cache duration in seconds */
     maxAge?: number;
-}): Middleware;
+    /** Exposed headers that can be accessed from the response */
+    exposeHeaders?: string[];
+}
+/**
+ * CORS middleware factory.
+ *
+ * Handles cross-origin resource sharing with best practices:
+ * - Adds Vary: Origin for dynamic origins (CDN compatibility)
+ * - Supports async origin validation
+ * - Proper preflight handling
+ *
+ * @example
+ * ```typescript
+ * // Allow specific origins
+ * chain.use(cors({ origin: ['https://app.example.com'] }));
+ *
+ * // Dynamic validation
+ * chain.use(cors({
+ *     origin: async (origin) => {
+ *         return await db.allowedOrigins.exists(origin);
+ *     }
+ * }));
+ * ```
+ */
+declare function cors(options?: CorsOptions): Middleware;
 /** Log levels in order of verbosity */
 type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
 /** Log format types */
@@ -136,6 +211,84 @@ declare function securityHeaders(options?: {
  * Compression middleware (requires implementation in adapter)
  */
 declare function compress(): Middleware;
+/**
+ * Error information passed to error handlers.
+ */
+interface ErrorInfo {
+    /** The original error */
+    error: Error;
+    /** HTTP status code (derived from error or default 500) */
+    status: number;
+    /** Error code for categorization */
+    code?: string;
+    /** Request context */
+    ctx: MiddlewareContext;
+    /** Request timestamp */
+    timestamp: string;
+}
+/**
+ * Error handler options.
+ */
+interface ErrorHandlerOptions {
+    /**
+     * Custom error handler function.
+     * Called when an error is caught. Can modify ctx to set response.
+     * If not provided, a default JSON response is sent.
+     */
+    onError?: (info: ErrorInfo) => void | Promise<void>;
+    /**
+     * Whether to expose error details in response.
+     * Set to false in production to hide internal error messages.
+     * @default false
+     */
+    expose?: boolean;
+    /**
+     * Default status code for errors without a status property.
+     * @default 500
+     */
+    defaultStatus?: number;
+    /**
+     * Emit error events for centralized logging (Koa pattern).
+     * Provide a function to receive error events.
+     */
+    emit?: (error: Error, ctx: MiddlewareContext) => void;
+}
+/**
+ * Error handler middleware factory.
+ *
+ * Provides centralized error handling following Koa best practices:
+ * - Catches all downstream errors
+ * - Sets appropriate status codes
+ * - Supports custom error handlers
+ * - Supports error event emission for logging
+ *
+ * Place this as one of the FIRST middleware in your chain.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage - default JSON error response
+ * chain.use(errorHandler());
+ *
+ * // With custom handler
+ * chain.use(errorHandler({
+ *     onError: ({ error, status, ctx }) => {
+ *         ctx.status = status;
+ *         ctx.responseBody = JSON.stringify({
+ *             error: error.message,
+ *             code: 'SERVER_ERROR'
+ *         });
+ *     },
+ *     emit: (error, ctx) => {
+ *         logger.error('Request error:', error);
+ *         errorTracker.capture(error);
+ *     }
+ * }));
+ *
+ * // Production-safe (hide error details)
+ * chain.use(errorHandler({ expose: false }));
+ * ```
+ */
+declare function errorHandler(options?: ErrorHandlerOptions): Middleware;
 /**
  * Create a middleware context from a Web Request
  */
@@ -149,4 +302,4 @@ declare function createResponseFromContext(ctx: MiddlewareContext): Response;
  */
 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 };
+export { type CorsOptions, type ErrorHandlerOptions, type ErrorInfo, 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, errorHandler, logger, securityHeaders };

package/dist/middleware/index.js

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

package/dist/rsc/index.d.ts

@@ -7,21 +7,226 @@ export { FlightResponseOptions, FlightStreamError, FlightStreamOptions, FlightSt
 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 { 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, withErrorBoundary } from './legacy.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';
 
+/**
+ * @flight-framework/core - RSC Type Helpers
+ *
+ * Type utilities for async server components, loaders, and actions.
+ * These types provide better TypeScript inference and developer experience.
+ *
+ * @module @flight-framework/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>;
-/**
- * Props for a component
- */
-type ComponentProps<T> = T extends (props: infer P, ...args: unknown[]) => unknown ? P : never;
 
-export { type ComponentProps, FlightElement, type ServerActionFn, type ServerComponentFn, ServerContext };
+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

@@ -1,15 +1,15 @@
 import '../chunk-63SCEXD7.js';
+import '../chunk-Y22AMGTM.js';
+export { createReactAdapter, createReactConsumer, markAsClientComponent } from '../chunk-HNPO6LFW.js';
+import '../chunk-3UQJE3XZ.js';
+import '../chunk-3N5ZBVZJ.js';
+import '../chunk-65JYF3DJ.js';
 export { acceptsJson, createServerContext, deleteCookie, getHeader, getHeaders, getPreferredLanguage, getRedirectInfo, isAjaxRequest, isBotRequest, isMutationRequest, isNotFoundError, isRedirectError, notFound, redirect, setCacheControl, setCookie, supportsStreaming } from '../chunk-CKJHJPKQ.js';
 export { FlightStreamError, consumeFlightStream, createFlightResponse, createFlightStream, createFlightStreamFromArray, createHybridResponse, createStreamController, mergeFlightStreams, parseFlightStream, parseFlightStreamSync, prettyPrintChunks, transformFlightStream } from '../chunk-A2QRUBVE.js';
 export { FlightRenderer, createRenderer, renderServerComponent, renderServerComponentStreaming } from '../chunk-FRAH5QNY.js';
 export { FlightPayloadError, FlightSerializationError, clientRef, createActionChunk, createClientChunk, createErrorChunk, createHintChunk, createServerChunk, deserialize, fragment, generateChunkId, h, isFlightElement, resetChunkIdCounter, serialize, suspense, text, toFlightElement } from '../chunk-6GI6HFSQ.js';
-export { composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError as legacyIsNotFoundError, isRedirectError as legacyIsRedirectError, notFound as legacyNotFound, redirect as legacyRedirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary } from '../chunk-2R23X5Z3.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-6IG6XIXU.js';
 export { flightRSC } from '../chunk-XU6MRYG2.js';
 export { BoundaryRegistry, CLIENT_REFERENCE, SERVER_REFERENCE, analyzeModule, createClientReference, createServerReference, detectAsyncComponents, detectBoundaryType, detectInlineServerActions, getReferenceId, globalRegistry, hasUseClientDirective, hasUseServerDirective, isClientReference, isServerReference, registerClientComponent, registerServerAction } from '../chunk-5XHOLZBJ.js';
-import '../chunk-Y22AMGTM.js';
-export { createReactAdapter, createReactConsumer, markAsClientComponent } from '../chunk-HNPO6LFW.js';
-import '../chunk-3UQJE3XZ.js';
-import '../chunk-3N5ZBVZJ.js';
-import '../chunk-65JYF3DJ.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/rsc/legacy.d.ts

@@ -99,9 +99,33 @@ declare function createAsyncComponent<P, T>(fetcher: (props: P, context: RenderC
  * @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 try/catch in async components
+ * @deprecated Use withAsyncErrorBoundary instead
  */
 declare function withErrorBoundary<P>(component: ServerComponent<P>, errorFallback: (error: Error) => string): ServerComponent<P>;
 /**
@@ -128,4 +152,4 @@ declare function isRedirectError(error: unknown): {
     type: string;
 } | null;
 
-export { type ClientComponent, type ComponentType, type RenderContext, type ServerComponent, composeComponents, createAsyncComponent, createClientBoundary, createRenderContext, deserializeProps, executeServerComponent, isNotFoundError, isRedirectError, notFound, redirect, revalidatePath, revalidateTag, serializeProps, serverFetch, withErrorBoundary };
+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

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

package/dist/server/index.js

@@ -1,6 +1,6 @@
-export { createServer, getRuntime, isFlightServer } from '../chunk-UL4Q5CIJ.js';
+export { createServer, getRuntime, isFlightServer } from '../chunk-KDEA64UX.js';
+import '../chunk-R7MEVVA4.js';
 import '../chunk-EHVUAFNH.js';
 import '../chunk-ARBKF6VI.js';
-import '../chunk-JFUKVWSO.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flight-framework/core",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Core primitives for Flight Framework - routing, rendering, caching",
   "keywords": [
     "flight",
@@ -15,7 +15,13 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "node": "./dist/index.js",
+      "default": "./dist/client.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "browser": "./dist/client.js",
+      "import": "./dist/client.js"
     },
     "./errors": {
       "types": "./dist/errors/index.d.ts",
@@ -168,6 +174,14 @@
     "./rsc/plugins/rollup": {
       "types": "./dist/rsc/plugins/rollup.d.ts",
       "import": "./dist/rsc/plugins/rollup.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/plugins/index.js"
+    },
+    "./plugins/critical-css": {
+      "types": "./dist/plugins/critical-css.d.ts",
+      "import": "./dist/plugins/critical-css.js"
     }
   },
   "main": "./dist/index.js",
@@ -188,7 +202,8 @@
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
-    "vite": "^6.0.0 || ^7.0.0"
+    "vite": "^6.0.0 || ^7.0.0",
+    "critters": ">=0.0.20"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -196,6 +211,9 @@
     },
     "vite": {
       "optional": true
+    },
+    "critters": {
+      "optional": true
     }
   },
   "scripts": {